[SDK-707] Replace request AsyncTask with SDK executor

Author: franco-zalamena-iterable

CHANGELOG.md

@@ -9,7 +9,7 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 - Added `IterableConfig.Builder.setInAppColorScheme()` and `setInAppColorSchemeProvider()` to control the color scheme reported to HTML in-app messages. The provider is evaluated for each new in-app message, allowing apps that keep their theme in Jetpack Compose state to return the current `LIGHT` or `DARK` scheme.
 
 ### Fixed
-- Push token registration, disable operations, and Iterable deep-link redirects now run on an SDK-owned serial executor instead of Android's process-wide `AsyncTask` queue, preventing host app background work from delaying SDK operations while preserving operation order. Deep-link callbacks and attribution updates continue on the main thread.
+- Push token registration, disable operations, Iterable deep-link redirects, and API requests now run on an SDK-owned serial executor instead of Android's process-wide `AsyncTask` queues, preventing host app background work from delaying SDK operations while preserving operation order. Deep-link callbacks, attribution updates, and API response callbacks continue on the main thread.
 - HTML in-app messages now follow the host activity's Android light-dark configuration instead of always rendering as if the device were in dark mode. Previously the in-app container always reported `prefers-color-scheme: dark` to the message HTML, so a campaign with an `@media (prefers-color-scheme: dark)` block rendered its dark styles even in light mode. Those campaigns now render their light styles in light mode; campaigns that don't declare dark styles, and rendering in dark mode, are unaffected.
 - Fixed the keychain treating a transient crypto timeout as a permanent decryption failure. A slow AndroidKeyStore operation that exceeded the 500 ms timeout would wipe the stored email, userId, and auth token and disable encryption, forcing the user to re-authenticate (and request a new auth token) on the next launch. Crypto timeouts are now handled as transient without wiping credentials or disabling encryption for the device: a read that times out returns no value for that call (the stored ciphertext is left intact for the next attempt), and a write that times out stores that one value unencrypted (as the non-encrypted fallback already did) rather than clearing everything. The timed-out crypto operation is also cancelled so it no longer blocks subsequent reads/writes.
 - `setExpiringAuthTokenRefreshPeriod` now validates its input instead of silently producing a broken refresh schedule. Previously a negative value was converted to a negative millisecond period and then *subtracted* when computing the refresh time, scheduling the refresh after the token had already expired; a very large value overflowed to a negative period with the same effect; and `null` threw a `NullPointerException` on unboxing. Invalid values (`null`, `NaN`, negatives) are now logged and ignored, leaving the period at whatever it was before the call — the 60 second default unless an earlier call set something else. Values above ~10 years are clamped to that ceiling rather than ignored. Zero remains valid and means the token is refreshed only once it has expired.

iterableapi/src/main/java/com/iterable/iterableapi/IterableApi.java

@@ -986,6 +986,10 @@ static void initializeForPush(@Nullable Context context) {
         this.embeddedManager = embeddedManager;
         this.pushRegistration = Objects.requireNonNull(pushRegistration);
     }
+    void setRequestDispatcher(IterableRequestDispatcher requestDispatcher) {
+        apiClient = new IterableApiClient(new IterableApiAuthProvider(),
+                Objects.requireNonNull(requestDispatcher));
+    }
 
 //endregion
 

iterableapi/src/main/java/com/iterable/iterableapi/IterableApiClient.java

@@ -20,6 +20,7 @@
 class IterableApiClient {
     private static final String TAG = "IterableApiClient";
     private final @NonNull AuthProvider authProvider;
+    private final @NonNull IterableRequestDispatcher requestDispatcher;
     private RequestProcessor requestProcessor;
 
     interface AuthProvider {
@@ -41,12 +42,20 @@ interface AuthProvider {
     }
 
     IterableApiClient(@NonNull AuthProvider authProvider) {
+        this(authProvider, IterableRequestDispatcher.sdk());
+    }
+
+    IterableApiClient(
+            @NonNull AuthProvider authProvider,
+            @NonNull IterableRequestDispatcher requestDispatcher
+    ) {
         this.authProvider = authProvider;
+        this.requestDispatcher = requestDispatcher;
     }
 
     private RequestProcessor getRequestProcessor() {
         if (requestProcessor == null) {
-            requestProcessor = new OnlineRequestProcessor();
+            requestProcessor = new OnlineRequestProcessor(requestDispatcher);
         }
         return requestProcessor;
     }
@@ -64,8 +73,8 @@ void setOfflineProcessingEnabled(boolean offlineMode) {
         }
 
         this.requestProcessor = offlineMode
-                ? new OfflineRequestProcessor(authProvider.getContext())
-                : new OnlineRequestProcessor();
+                ? new OfflineRequestProcessor(authProvider.getContext(), requestDispatcher)
+                : new OnlineRequestProcessor(requestDispatcher);
     }
 
     void getRemoteConfiguration(IterableHelper.IterableActionHandler actionHandler) {

iterableapi/src/main/java/com/iterable/iterableapi/IterableRequestDispatcher.java

@@ -0,0 +1,54 @@
+package com.iterable.iterableapi;
+
+import android.os.Handler;
+import android.os.Looper;
+
+import java.util.concurrent.Executor;
+
+final class IterableRequestDispatcher {
+    interface RetryScheduler {
+        void schedule(Runnable runnable, long delayMs);
+    }
+
+    private static final IterableRequestDispatcher SDK_DISPATCHER =
+            new IterableRequestDispatcher(
+                    IterableExecutors.serial(),
+                    IterableExecutors.main(),
+                    (runnable, delayMs) ->
+                            new Handler(Looper.getMainLooper()).postDelayed(runnable, delayMs)
+            );
+
+    private final Executor requestExecutor;
+    private final Executor callbackExecutor;
+    private final RetryScheduler retryScheduler;
+
+    static IterableRequestDispatcher sdk() {
+        return SDK_DISPATCHER;
+    }
+
+    IterableRequestDispatcher(
+            Executor requestExecutor,
+            Executor callbackExecutor,
+            RetryScheduler retryScheduler
+    ) {
+        this.requestExecutor = requestExecutor;
+        this.callbackExecutor = callbackExecutor;
+        this.retryScheduler = retryScheduler;
+    }
+
+    void execute(IterableApiRequest request) {
+        execute(request, 0);
+    }
+
+    void execute(IterableApiRequest request, int retryCount) {
+        requestExecutor.execute(new IterableRequestTask(request, retryCount, this));
+    }
+
+    void deliverResult(Runnable runnable) {
+        callbackExecutor.execute(runnable);
+    }
+
+    void retry(IterableApiRequest request, int retryCount, long delayMs) {
+        retryScheduler.schedule(() -> execute(request, retryCount), delayMs);
+    }
+}

iterableapi/src/main/java/com/iterable/iterableapi/IterableRequestTask.java

@@ -4,9 +4,6 @@
 import static com.iterable.iterableapi.IterableConstants.ENDPOINT_GET_REMOTE_CONFIGURATION;
 
 import android.net.Uri;
-import android.os.AsyncTask;
-import android.os.Handler;
-import android.os.Looper;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -29,10 +26,10 @@
 import java.util.Objects;
 
 /**
- * Async task to handle sending data to the Iterable server
+ * Runnable task to handle sending data to the Iterable server
  * Created by David Truong dt@iterable.com
  */
-class IterableRequestTask extends AsyncTask<IterableApiRequest, Void, IterableApiResponse> {
+class IterableRequestTask implements Runnable {
     static final String TAG = "IterableRequest";
 
     static String overrideUrl;
@@ -45,37 +42,56 @@ class IterableRequestTask extends AsyncTask<IterableApiRequest, Void, IterableAp
     static final String ERROR_CODE_INVALID_JWT_PAYLOAD = "InvalidJwtPayload";
     static final String ERROR_CODE_MISSING_JWT_PAYLOAD = "BadAuthorizationHeader";
     static final String ERROR_CODE_JWT_USER_IDENTIFIERS_MISMATCHED = "JwtUserIdentifiersMismatched";
-    int retryCount = 0;
-    IterableApiRequest iterableApiRequest;
+    private final int retryCount;
+    private final IterableApiRequest iterableApiRequest;
+    private final IterableRequestDispatcher requestDispatcher;
+
+    IterableRequestTask(
+            IterableApiRequest iterableApiRequest,
+            int retryCount,
+            IterableRequestDispatcher requestDispatcher
+    ) {
+        this.iterableApiRequest = iterableApiRequest;
+        this.retryCount = retryCount;
+        this.requestDispatcher = requestDispatcher;
+    }
 
-    /**
-     * Sends the given request to Iterable using a HttpUserConnection
-     * Reference - http://developer.android.com/reference/java/net/HttpURLConnection.html
-     *
-     * @param params
-     * @return
-     */
-    protected IterableApiResponse doInBackground(IterableApiRequest... params) {
-        if (params != null && params.length > 0) {
-            iterableApiRequest = params[0];
-        }
-        return executeApiRequest(iterableApiRequest);
+    @Override
+    public void run() {
+        IterableApiResponse response = executeApiRequest(iterableApiRequest, requestDispatcher);
+        requestDispatcher.deliverResult(() -> handleResponse(response));
     }
 
-    private static void retryRequestWithNewAuthToken(String newAuthToken, IterableApiRequest iterableApiRequest) {
+    static void retryRequestWithNewAuthToken(
+            String newAuthToken,
+            IterableApiRequest iterableApiRequest,
+            IterableRequestDispatcher requestDispatcher
+    ) {
         IterableApiRequest request = new IterableApiRequest(
                 iterableApiRequest.apiKey,
                 iterableApiRequest.resourcePath,
                 iterableApiRequest.json,
                 iterableApiRequest.requestType,
                 newAuthToken,
-                iterableApiRequest.legacyCallback);
-        IterableRequestTask requestTask = new IterableRequestTask();
-        requestTask.execute(request);
+                iterableApiRequest.legacyCallback
+        );
+        requestDispatcher.execute(request);
     }
 
     @WorkerThread
     static IterableApiResponse executeApiRequest(IterableApiRequest iterableApiRequest) {
+        return executeApiRequest(iterableApiRequest, IterableRequestDispatcher.sdk());
+    }
+
+    /**
+     * Sends the given request to Iterable using a HttpURLConnection.
+     * Reference - http://developer.android.com/reference/java/net/HttpURLConnection.html
+     */
+    @WorkerThread
+    private static IterableApiResponse executeApiRequest(
+            IterableApiRequest iterableApiRequest,
+            IterableRequestDispatcher requestDispatcher
+    ) {
         IterableApiResponse apiResponse = null;
         String requestResult = null;
 
@@ -204,7 +220,7 @@ static IterableApiResponse executeApiRequest(IterableApiRequest iterableApiReque
                         apiResponse = IterableApiResponse.failure(responseCode, requestResult, jsonResponse, "JWT Authorization header error");
                         IterableApi.getInstance().getAuthManager().handleAuthFailure(iterableApiRequest.authToken, getMappedErrorCodeForMessage(jsonResponse));
 
-                        handleJwtAuthRetry(iterableApiRequest);
+                        handleJwtAuthRetry(iterableApiRequest, requestDispatcher);
                     } else {
                         apiResponse = IterableApiResponse.failure(responseCode, requestResult, jsonResponse, "Invalid API Key");
                     }
@@ -264,7 +280,10 @@ static IterableApiResponse executeApiRequest(IterableApiRequest iterableApiReque
      * is obtained via the AuthTokenReadyListener callback.
      * For online requests or when autoRetry is disabled, use the existing inline retry.
      */
-    private static void handleJwtAuthRetry(IterableApiRequest iterableApiRequest) {
+    private static void handleJwtAuthRetry(
+            IterableApiRequest iterableApiRequest,
+            IterableRequestDispatcher requestDispatcher
+    ) {
         boolean autoRetry = IterableApi.getInstance().isAutoRetryOnJwtFailure();
         if (autoRetry && iterableApiRequest.getProcessorType() == IterableApiRequest.ProcessorType.OFFLINE) {
             IterableAuthManager authManager = IterableApi.getInstance().getAuthManager();
@@ -276,7 +295,7 @@ private static void handleJwtAuthRetry(IterableApiRequest iterableApiRequest) {
                     null
             );
         } else {
-            requestNewAuthTokenAndRetry(iterableApiRequest);
+            requestNewAuthTokenAndRetry(iterableApiRequest, requestDispatcher);
         }
     }
 
@@ -363,11 +382,7 @@ private static boolean isSensitive(String key) {
         return (key.equals(IterableConstants.HEADER_API_KEY)) || key.equals(IterableConstants.HEADER_SDK_AUTHORIZATION);
     }
 
-    private static final Handler handler = new Handler(Looper.getMainLooper());
-
-    @Override
-    protected void onPostExecute(IterableApiResponse response) {
-
+    void handleResponse(IterableApiResponse response) {
         if (shouldRetry(response)) {
             retryRequestWithDelay();
             return;
@@ -380,25 +395,15 @@ protected void onPostExecute(IterableApiResponse response) {
         if (iterableApiRequest.legacyCallback != null) {
             iterableApiRequest.legacyCallback.execute(response.responseBody);
         }
-        super.onPostExecute(response);
     }
 
     private boolean shouldRetry(IterableApiResponse response) {
         return !response.success && response.responseCode >= 500 && retryCount <= MAX_RETRY_COUNT;
     }
 
     private void retryRequestWithDelay() {
-        final IterableRequestTask requestTask = new IterableRequestTask();
-        requestTask.setRetryCount(retryCount + 1);
-
         long delay = (retryCount > 2) ? RETRY_DELAY_MS * retryCount : 0;
-
-        handler.postDelayed(new Runnable() {
-            @Override
-            public void run() {
-                requestTask.execute(iterableApiRequest);
-            }
-        }, delay);
+        requestDispatcher.retry(iterableApiRequest, retryCount + 1, delay);
     }
 
     private void handleSuccessResponse(IterableApiResponse response) {
@@ -425,7 +430,10 @@ private void handleErrorResponse(IterableApiResponse response) {
         }
     }
 
-    private static void requestNewAuthTokenAndRetry(IterableApiRequest iterableApiRequest) {
+    private static void requestNewAuthTokenAndRetry(
+            IterableApiRequest iterableApiRequest,
+            IterableRequestDispatcher requestDispatcher
+    ) {
         IterableApi.getInstance().getAuthManager().setIsLastAuthTokenValid(false);
         long retryInterval = IterableApi.getInstance().getAuthManager().getNextRetryInterval();
         IterableApi.getInstance().getAuthManager().scheduleAuthTokenRefresh(
@@ -434,17 +442,17 @@ private static void requestNewAuthTokenAndRetry(IterableApiRequest iterableApiRe
                 data -> {
                     try {
                         String newAuthToken = data.getString("newAuthToken");
-                        retryRequestWithNewAuthToken(newAuthToken, iterableApiRequest);
+                        retryRequestWithNewAuthToken(
+                                newAuthToken,
+                                iterableApiRequest,
+                                requestDispatcher
+                        );
                     } catch (JSONException e) {
                         e.printStackTrace();
                     }
                 }
         );
     }
-
-    protected void setRetryCount(int count) {
-        retryCount = count;
-    }
 }
 
 /**