Merge branch 'master' into MOB-8451

hardikmashru · web-flow · commit 0f1d4b898a2a · 2024-05-17T11:45:22.000+05:30
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -13,6 +13,15 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 #### Changed
 - nothing yet
 
+## [3.5.2]
+#### Added
+ - Introducing a new method `setAuthRetryPolicy` in `IterableConfig` to set the retry policy for JWT token refresh.
+ - You can now use method - `pauseAuthRetries(boolean pauseRetry)` to pause or resume the JWT token refresh retries.
+ - `trackPurchase` method now accepts `attributionInfo` parameter to track purchase with attribution information.
+
+#### Fixed
+- Embedded manager listeners are active only if feature is enabled
+
 ## [3.5.1]
 
 #### Fixed
diff --git a/iterableapi-ui/build.gradle b/iterableapi-ui/build.gradle
@@ -51,7 +51,7 @@ dependencies {
 
 ext {
     libraryName = 'iterableapi-ui'
-    libraryVersion = '3.5.1'
+    libraryVersion = '3.5.2'
 }
 
 if (hasProperty("mavenPublishEnabled")) {
diff --git a/iterableapi/build.gradle b/iterableapi/build.gradle
@@ -19,7 +19,7 @@ android {
         minSdkVersion 16
         targetSdkVersion 27
 
-        buildConfigField "String", "ITERABLE_SDK_VERSION", "\"3.5.1\""
+        buildConfigField "String", "ITERABLE_SDK_VERSION", "\"3.5.2\""
 
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
     }
@@ -85,7 +85,7 @@ dependencies {
 
 ext {
     libraryName = 'iterableapi'
-    libraryVersion = '3.5.1'
+    libraryVersion = '3.5.2'
 }
 
 if (hasProperty("mavenPublishEnabled")) {
diff --git a/iterableapi/src/main/java/com/iterable/iterableapi/IterableApi.java b/iterableapi/src/main/java/com/iterable/iterableapi/IterableApi.java
@@ -131,7 +131,7 @@ Context getMainActivityContext() {
     @NonNull
     IterableAuthManager getAuthManager() {
         if (authManager == null) {
-            authManager = new IterableAuthManager(this, config.authHandler, config.expiringAuthTokenRefreshPeriod);
+            authManager = new IterableAuthManager(this, config.authHandler, config.retryPolicy, config.expiringAuthTokenRefreshPeriod);
         }
         return authManager;
     }
@@ -344,7 +344,7 @@ private void logoutPreviousUser() {
 
         getInAppManager().reset();
         getEmbeddedManager().reset();
-        getAuthManager().clearRefreshTimer();
+        getAuthManager().reset();
 
         apiClient.onLogout();
     }
@@ -355,6 +355,7 @@ private void onLogin(@Nullable String authToken) {
             return;
         }
 
+        getAuthManager().pauseAuthRetries(false);
         if (authToken != null) {
             setAuthToken(authToken);
         } else {
@@ -457,7 +458,7 @@ private void retrieveEmailAndUserId() {
                 getAuthManager().queueExpirationRefresh(_authToken);
             } else {
                 IterableLogger.d(TAG, "Auth token found as null. Scheduling token refresh in 10 seconds...");
-                getAuthManager().scheduleAuthTokenRefresh(10000);
+                getAuthManager().scheduleAuthTokenRefresh(authManager.getNextRetryInterval(), true, null);
             }
         }
     }
@@ -697,6 +698,17 @@ public IterableAttributionInfo getAttributionInfo() {
         );
     }
 
+    /**
+     * // This method gets called from developer end only.
+     * @param pauseRetry to pause/unpause auth retries
+     */
+    public void pauseAuthRetries(boolean pauseRetry) {
+        getAuthManager().pauseAuthRetries(pauseRetry);
+        if (!pauseRetry) { // request new auth token as soon as unpause
+            getAuthManager().requestNewAuthToken(false);
+        }
+    }
+
     public void setEmail(@Nullable String email) {
         setEmail(email, null, null, null);
     }
diff --git a/iterableapi/src/main/java/com/iterable/iterableapi/IterableAuthManager.java b/iterableapi/src/main/java/com/iterable/iterableapi/IterableAuthManager.java
@@ -1,7 +1,6 @@
 package com.iterable.iterableapi;
 
 import android.util.Base64;
-
 import androidx.annotation.VisibleForTesting;
 
 import org.json.JSONException;
@@ -20,23 +19,46 @@ public class IterableAuthManager {
     private final IterableApi api;
     private final IterableAuthHandler authHandler;
     private final long expiringAuthTokenRefreshPeriod;
-    private final long scheduledRefreshPeriod = 10000;
     @VisibleForTesting
     Timer timer;
     private boolean hasFailedPriorAuth;
     private boolean pendingAuth;
     private boolean requiresAuthRefresh;
+    RetryPolicy authRetryPolicy;
+    boolean pauseAuthRetry;
+    int retryCount;
+    private boolean isLastAuthTokenValid;
+    private boolean isTimerScheduled;
 
     private final ExecutorService executor = Executors.newSingleThreadExecutor();
 
-    IterableAuthManager(IterableApi api, IterableAuthHandler authHandler, long expiringAuthTokenRefreshPeriod) {
+    IterableAuthManager(IterableApi api, IterableAuthHandler authHandler, RetryPolicy authRetryPolicy, long expiringAuthTokenRefreshPeriod) {
         this.api = api;
         this.authHandler = authHandler;
+        this.authRetryPolicy = authRetryPolicy;
         this.expiringAuthTokenRefreshPeriod = expiringAuthTokenRefreshPeriod;
     }
 
     public synchronized void requestNewAuthToken(boolean hasFailedPriorAuth) {
-        requestNewAuthToken(hasFailedPriorAuth, null);
+        requestNewAuthToken(hasFailedPriorAuth, null, true);
+    }
+
+    public void pauseAuthRetries(boolean pauseRetry) {
+        pauseAuthRetry = pauseRetry;
+        resetRetryCount();
+    }
+
+    void reset() {
+        clearRefreshTimer();
+        setIsLastAuthTokenValid(false);
+    }
+
+    void setIsLastAuthTokenValid(boolean isValid) {
+        isLastAuthTokenValid = isValid;
+    }
+
+    void resetRetryCount() {
+        retryCount = 0;
     }
 
     private void handleSuccessForAuthToken(String authToken, IterableHelper.SuccessHandler successCallback) {
@@ -51,7 +73,12 @@ private void handleSuccessForAuthToken(String authToken, IterableHelper.SuccessH
 
     public synchronized void requestNewAuthToken(
             boolean hasFailedPriorAuth,
-            final IterableHelper.SuccessHandler successCallback) {
+            final IterableHelper.SuccessHandler successCallback,
+            boolean shouldIgnoreRetryPolicy) {
+        if ((!shouldIgnoreRetryPolicy && pauseAuthRetry) || (retryCount >= authRetryPolicy.maxRetry && !shouldIgnoreRetryPolicy)) {
+            return;
+        }
+
         if (authHandler != null) {
             if (!pendingAuth) {
                 if (!(this.hasFailedPriorAuth && hasFailedPriorAuth)) {
@@ -62,9 +89,17 @@ public synchronized void requestNewAuthToken(
                         @Override
                         public void run() {
                             try {
+                                if (isLastAuthTokenValid && !shouldIgnoreRetryPolicy) {
+                                    // if some JWT retry had valid token it will not fetch the auth token again from developer function
+                                    handleAuthTokenSuccess(IterableApi.getInstance().getAuthToken(), successCallback);
+                                    return;
+                                }
                                 final String authToken = authHandler.onAuthTokenRequested();
+                                pendingAuth = false;
+                                retryCount++;
                                 handleAuthTokenSuccess(authToken, successCallback);
                             } catch (final Exception e) {
+                                retryCount++;
                                 handleAuthTokenFailure(e);
                             }
                         }
@@ -89,12 +124,11 @@ private void handleAuthTokenSuccess(String authToken, IterableHelper.SuccessHand
         } else {
             IterableLogger.w(TAG, "Auth token received as null. Calling the handler in 10 seconds");
             //TODO: Make this time configurable and in sync with SDK initialization flow for auth null scenario
-            scheduleAuthTokenRefresh(scheduledRefreshPeriod);
+            scheduleAuthTokenRefresh(getNextRetryInterval(), false, null);
             authHandler.onTokenRegistrationFailed(new Throwable("Auth token null"));
             return;
         }
         IterableApi.getInstance().setAuthToken(authToken);
-        pendingAuth = false;
         reSyncAuth();
         authHandler.onTokenRegistrationSuccessful(authToken);
     }
@@ -103,7 +137,7 @@ private void handleAuthTokenFailure(Throwable throwable) {
         IterableLogger.e(TAG, "Error while requesting Auth Token", throwable);
         authHandler.onTokenRegistrationFailed(throwable);
         pendingAuth = false;
-        reSyncAuth();
+        scheduleAuthTokenRefresh(getNextRetryInterval(), false, null);
     }
 
     public void queueExpirationRefresh(String encodedJWT) {
@@ -112,15 +146,15 @@ public void queueExpirationRefresh(String encodedJWT) {
             long expirationTimeSeconds = decodedExpiration(encodedJWT);
             long triggerExpirationRefreshTime = expirationTimeSeconds * 1000L - expiringAuthTokenRefreshPeriod - IterableUtil.currentTimeMillis();
             if (triggerExpirationRefreshTime > 0) {
-                scheduleAuthTokenRefresh(triggerExpirationRefreshTime);
+                scheduleAuthTokenRefresh(triggerExpirationRefreshTime, true, null);
             } else {
                 IterableLogger.w(TAG, "The expiringAuthTokenRefreshPeriod has already passed for the current JWT");
             }
         } catch (Exception e) {
             IterableLogger.e(TAG, "Error while parsing JWT for the expiration", e);
             authHandler.onTokenRegistrationFailed(new Throwable("Auth token decode failure. Scheduling auth token refresh in 10 seconds..."));
             //TODO: Sync with configured time duration once feature is available.
-            scheduleAuthTokenRefresh(scheduledRefreshPeriod);
+            scheduleAuthTokenRefresh(getNextRetryInterval(), false, null);
         }
     }
 
@@ -131,28 +165,57 @@ void resetFailedAuth() {
     void reSyncAuth() {
         if (requiresAuthRefresh) {
             requiresAuthRefresh = false;
-            requestNewAuthToken(false);
+            scheduleAuthTokenRefresh(getNextRetryInterval(), false, null);
         }
     }
 
-    void scheduleAuthTokenRefresh(long timeDuration) {
-        timer = new Timer(true);
+    long getNextRetryInterval() {
+        long nextRetryInterval = authRetryPolicy.retryInterval;
+        if (authRetryPolicy.retryBackoff == RetryPolicy.Type.EXPONENTIAL) {
+            nextRetryInterval *= Math.pow(IterableConstants.EXPONENTIAL_FACTOR, retryCount - 1); // Exponential backoff
+        }
+
+        return nextRetryInterval;
+    }
+
+    void scheduleAuthTokenRefresh(long timeDuration, boolean isScheduledRefresh, final IterableHelper.SuccessHandler successCallback) {
+        if ((pauseAuthRetry && !isScheduledRefresh) || isTimerScheduled) {
+            // we only stop schedule token refresh if it is called from retry (in case of failure). The normal auth token refresh schedule would work
+            return;
+        }
+        if (timer == null) {
+            timer = new Timer(true);
+        }
         try {
             timer.schedule(new TimerTask() {
                 @Override
                 public void run() {
                     if (api.getEmail() != null || api.getUserId() != null) {
-                        api.getAuthManager().requestNewAuthToken(false);
+                        api.getAuthManager().requestNewAuthToken(false, successCallback, isScheduledRefresh);
                     } else {
                         IterableLogger.w(TAG, "Email or userId is not available. Skipping token refresh");
                     }
+                    isTimerScheduled = false;
                 }
             }, timeDuration);
+            isTimerScheduled = true;
         } catch (Exception e) {
             IterableLogger.e(TAG, "timer exception: " + timer, e);
         }
     }
 
+    private String getEmailOrUserId() {
+        String email = api.getEmail();
+        String userId = api.getUserId();
+
+        if (email != null) {
+            return email;
+        } else if (userId != null) {
+            return userId;
+        }
+        return null;
+    }
+
     private static long decodedExpiration(String encodedJWT) throws Exception {
         long exp = 0;
             String[] split = encodedJWT.split("\\.");
diff --git a/iterableapi/src/main/java/com/iterable/iterableapi/IterableConfig.java b/iterableapi/src/main/java/com/iterable/iterableapi/IterableConfig.java
@@ -65,6 +65,11 @@ public class IterableConfig {
      */
     final long expiringAuthTokenRefreshPeriod;
 
+    /**
+     * Retry policy for JWT Refresh.
+     */
+    final RetryPolicy retryPolicy;
+
     /**
      * By default, the SDK allows navigation/calls to URLs with the `https` protocol (e.g. deep links or external links)
      * If you'd like to allow other protocols like `http`, `tel`, etc., add them to the `allowedProtocols` array
@@ -100,6 +105,7 @@ private IterableConfig(Builder builder) {
         inAppDisplayInterval = builder.inAppDisplayInterval;
         authHandler = builder.authHandler;
         expiringAuthTokenRefreshPeriod = builder.expiringAuthTokenRefreshPeriod;
+        retryPolicy = builder.retryPolicy;
         allowedProtocols = builder.allowedProtocols;
         dataRegion = builder.dataRegion;
         useInMemoryStorageForInApps = builder.useInMemoryStorageForInApps;
@@ -118,6 +124,7 @@ public static class Builder {
         private double inAppDisplayInterval = 30.0;
         private IterableAuthHandler authHandler;
         private long expiringAuthTokenRefreshPeriod = 60000L;
+        private RetryPolicy retryPolicy = new RetryPolicy(10, 6L, RetryPolicy.Type.LINEAR);
         private String[] allowedProtocols = new String[0];
         private IterableDataRegion dataRegion = IterableDataRegion.US;
         private boolean useInMemoryStorageForInApps = false;
@@ -224,6 +231,16 @@ public Builder setAuthHandler(@NonNull IterableAuthHandler authHandler) {
             return this;
         }
 
+        /**
+         * Set retry policy for JWT Refresh
+         * @param retryPolicy
+         */
+        @NonNull
+        public Builder setAuthRetryPolicy(@NonNull RetryPolicy retryPolicy) {
+            this.retryPolicy = retryPolicy;
+            return this;
+        }
+
         /**
          * Set a custom period before an auth token expires to automatically retrieve a new token
          * @param period in seconds
diff --git a/iterableapi/src/main/java/com/iterable/iterableapi/IterableConstants.java b/iterableapi/src/main/java/com/iterable/iterableapi/IterableConstants.java
@@ -260,6 +260,8 @@ public final class IterableConstants {
     public static final int ITERABLE_IN_APP_ANIMATION_DURATION           = 500;
     public static final int ITERABLE_IN_APP_BACKGROUND_ANIMATION_DURATION = 300;
 
+    public static final int EXPONENTIAL_FACTOR                              = 2;
+
     public static final double ITERABLE_IN_APP_PRIORITY_LEVEL_LOW           = 400.0;
     public static final double ITERABLE_IN_APP_PRIORITY_LEVEL_MEDIUM        = 300.0;
     public static final double ITERABLE_IN_APP_PRIORITY_LEVEL_HIGH          = 200.0;
diff --git a/iterableapi/src/main/java/com/iterable/iterableapi/IterableRequestTask.java b/iterableapi/src/main/java/com/iterable/iterableapi/IterableRequestTask.java
diff --git a/iterableapi/src/main/java/com/iterable/iterableapi/RetryPolicy.java b/iterableapi/src/main/java/com/iterable/iterableapi/RetryPolicy.java
diff --git a/sample-apps/inbox-customization/app/build.gradle b/sample-apps/inbox-customization/app/build.gradle

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ dependencies {`
`51`	`51`
`52`	`52`	`ext {`
`53`	`53`	`libraryName = 'iterableapi-ui'`
`54`		`- libraryVersion = '3.5.1'`
	`54`	`+ libraryVersion = '3.5.2'`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`if (hasProperty("mavenPublishEnabled")) {`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ android {`
`19`	`19`	`minSdkVersion 16`
`20`	`20`	`targetSdkVersion 27`
`21`	`21`
`22`		`- buildConfigField "String", "ITERABLE_SDK_VERSION", "\"3.5.1\""`
	`22`	`+ buildConfigField "String", "ITERABLE_SDK_VERSION", "\"3.5.2\""`
`23`	`23`
`24`	`24`	`testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"`
`25`	`25`	`}`
`@@ -85,7 +85,7 @@ dependencies {`
`85`	`85`
`86`	`86`	`ext {`
`87`	`87`	`libraryName = 'iterableapi'`
`88`		`- libraryVersion = '3.5.1'`
	`88`	`+ libraryVersion = '3.5.2'`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`if (hasProperty("mavenPublishEnabled")) {`
Original file line number	Diff line number	Diff line change
`@@ -131,7 +131,7 @@ Context getMainActivityContext() {`
`131`	`131`	`@NonNull`
`132`	`132`	`IterableAuthManager getAuthManager() {`
`133`	`133`	`if (authManager == null) {`
`134`		`- authManager = new IterableAuthManager(this, config.authHandler, config.expiringAuthTokenRefreshPeriod);`
	`134`	`+ authManager = new IterableAuthManager(this, config.authHandler, config.retryPolicy, config.expiringAuthTokenRefreshPeriod);`
`135`	`135`	`}`
`136`	`136`	`return authManager;`
`137`	`137`	`}`
`@@ -344,7 +344,7 @@ private void logoutPreviousUser() {`
`344`	`344`
`345`	`345`	`getInAppManager().reset();`
`346`	`346`	`getEmbeddedManager().reset();`
`347`		`- getAuthManager().clearRefreshTimer();`
	`347`	`+ getAuthManager().reset();`
`348`	`348`
`349`	`349`	`apiClient.onLogout();`
`350`	`350`	`}`
`@@ -355,6 +355,7 @@ private void onLogin(@Nullable String authToken) {`
`355`	`355`	`return;`
`356`	`356`	`}`
`357`	`357`
	`358`	`+ getAuthManager().pauseAuthRetries(false);`
`358`	`359`	`if (authToken != null) {`
`359`	`360`	`setAuthToken(authToken);`
`360`	`361`	`} else {`
`@@ -457,7 +458,7 @@ private void retrieveEmailAndUserId() {`
`457`	`458`	`getAuthManager().queueExpirationRefresh(_authToken);`
`458`	`459`	`} else {`
`459`	`460`	`IterableLogger.d(TAG, "Auth token found as null. Scheduling token refresh in 10 seconds...");`
`460`		`- getAuthManager().scheduleAuthTokenRefresh(10000);`
	`461`	`+ getAuthManager().scheduleAuthTokenRefresh(authManager.getNextRetryInterval(), true, null);`
`461`	`462`	`}`
`462`	`463`	`}`
`463`	`464`	`}`
`@@ -697,6 +698,17 @@ public IterableAttributionInfo getAttributionInfo() {`
`697`	`698`	`);`
`698`	`699`	`}`
`699`	`700`
	`701`	`+ /**`
	`702`	`+ * // This method gets called from developer end only.`
	`703`	`+ * @param pauseRetry to pause/unpause auth retries`
	`704`	`+ */`
	`705`	`+ public void pauseAuthRetries(boolean pauseRetry) {`
	`706`	`+ getAuthManager().pauseAuthRetries(pauseRetry);`
	`707`	`+ if (!pauseRetry) { // request new auth token as soon as unpause`
	`708`	`+ getAuthManager().requestNewAuthToken(false);`
	`709`	`+ }`
	`710`	`+ }`
	`711`	`+`
`700`	`712`	`public void setEmail(@Nullable String email) {`
`701`	`713`	`setEmail(email, null, null, null);`
`702`	`714`	`}`