SDK-324 - Updated way of handling notifications to not use AsyncTask

CHANGELOG.md

@@ -2,6 +2,9 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## Unreleased
+- Replaced the deprecated `AsyncTask`-based push notification handling with `WorkManager` for improved reliability and compatibility with modern Android versions. No action is required.
+
 ## [3.6.6]
 ### Fixed
 - Fixed push notifications killing the existing activity when opened

iterableapi/build.gradle

@@ -63,6 +63,7 @@ dependencies {
     api 'com.google.firebase:firebase-messaging:20.3.0'
     implementation 'com.google.code.gson:gson:2.10.1'
     implementation "androidx.security:security-crypto:1.1.0-alpha06"
+    implementation 'androidx.work:work-runtime:2.9.0'
 
     testImplementation 'junit:junit:4.13.2'
     testImplementation 'androidx.test:runner:1.6.2'
@@ -75,6 +76,7 @@ dependencies {
     testImplementation 'org.khronos:opengl-api:gl1.1-android-2.1_r1'
     testImplementation 'com.squareup.okhttp3:mockwebserver:4.9.3'
     testImplementation 'org.skyscreamer:jsonassert:1.5.0'
+    testImplementation 'androidx.work:work-testing:2.9.0'
     testImplementation project(':iterableapi')
 
     androidTestImplementation 'androidx.test:runner:1.6.2'

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

@@ -1,8 +1,8 @@
 package com.iterable.iterableapi;
 
 import android.content.Context;
-import android.os.AsyncTask;
 import android.os.Bundle;
+
 import androidx.annotation.NonNull;
 
 import com.google.android.gms.tasks.Tasks;
@@ -11,6 +11,7 @@
 import com.google.firebase.messaging.RemoteMessage;
 
 import java.util.Map;
+import java.util.UUID;
 import java.util.concurrent.ExecutionException;
 
 public class IterableFirebaseMessagingService extends FirebaseMessagingService {
@@ -56,12 +57,17 @@ public static boolean handleMessageReceived(@NonNull Context context, @NonNull R
             return false;
         }
 
-        if (!IterableNotificationHelper.isGhostPush(extras)) {
+        boolean isGhostPush = IterableNotificationHelper.isGhostPush(extras);
+
+        if (!isGhostPush) {
             if (!IterableNotificationHelper.isEmptyBody(extras)) {
                 IterableLogger.d(TAG, "Iterable push received " + messageData);
-                IterableNotificationBuilder notificationBuilder = IterableNotificationHelper.createNotification(
-                        context.getApplicationContext(), extras);
-                new IterableNotificationManager().execute(notificationBuilder);
+
+                if (IterableNotificationHelper.hasAttachmentUrl(extras)) {
+                    enqueueNotificationWork(context, extras);
+                } else {
+                    handleNow(context, extras);
+                }
             } else {
                 IterableLogger.d(TAG, "Iterable OS notification push received");
             }
@@ -105,9 +111,7 @@ public static String getFirebaseToken() {
         String registrationToken = null;
         try {
             registrationToken = Tasks.await(FirebaseMessaging.getInstance().getToken());
-        } catch (ExecutionException e) {
-            IterableLogger.e(TAG, e.getLocalizedMessage());
-        } catch (InterruptedException e) {
+        } catch (ExecutionException | InterruptedException e) {
             IterableLogger.e(TAG, e.getLocalizedMessage());
         } catch (Exception e) {
             IterableLogger.e(TAG, "Failed to fetch firebase token");
@@ -122,25 +126,60 @@ public static String getFirebaseToken() {
      * @return Boolean indicating whether the message is an Iterable ghost push or silent push
      */
     public static boolean isGhostPush(RemoteMessage remoteMessage) {
-        Map<String, String> messageData = remoteMessage.getData();
+        try {
+            Map<String, String> messageData = remoteMessage.getData();
+
+            if (messageData.isEmpty()) {
+                return false;
+            }
 
-        if (messageData == null || messageData.isEmpty()) {
+            Bundle extras = IterableNotificationHelper.mapToBundle(messageData);
+            return IterableNotificationHelper.isGhostPush(extras);
+        } catch (Exception e) {
+            IterableLogger.e(TAG, e.getMessage());
             return false;
         }
+    }
 
-        Bundle extras = IterableNotificationHelper.mapToBundle(messageData);
-        return IterableNotificationHelper.isGhostPush(extras);
+    private static void enqueueNotificationWork(@NonNull final Context context, @NonNull final Bundle extras) {
+        IterableNotificationWorkScheduler scheduler = new IterableNotificationWorkScheduler(context);
+
+        scheduler.scheduleNotificationWork(
+                extras,
+                new IterableNotificationWorkScheduler.SchedulerCallback() {
+                    @Override
+                    public void onScheduleSuccess(UUID workId) {
+                        IterableLogger.d(TAG, "Notification work scheduled: " + workId);
+                    }
+
+                    @Override
+                    public void onScheduleFailure(Exception exception, Bundle notificationData) {
+                        IterableLogger.e(TAG, "Failed to schedule notification work, falling back to immediate posting", exception);
+                        handleNow(context, notificationData);
+                    }
+                }
+        );
     }
-}
 
-class IterableNotificationManager extends AsyncTask<IterableNotificationBuilder, Void, Void> {
+    private static void handleNow(@NonNull Context context, @NonNull Bundle extras) {
+        Bundle safeExtras = extras;
 
-    @Override
-    protected Void doInBackground(IterableNotificationBuilder... params) {
-        if (params != null && params[0] != null) {
-            IterableNotificationBuilder notificationBuilder = params[0];
-            IterableNotificationHelper.postNotificationOnDevice(notificationBuilder.context, notificationBuilder);
+        if (IterableNotificationHelper.hasAttachmentUrl(extras)) {
+            IterableLogger.w(TAG, "image found when handling on main thread, removing it for safe handling");
+            safeExtras = IterableNotificationHelper.removePushImageFromBundle(extras);
+        }
+
+        try {
+            IterableNotificationBuilder notificationBuilder = IterableNotificationHelper
+                .createNotification(
+                    context.getApplicationContext(),
+                    safeExtras
+                );
+            if (notificationBuilder != null) {
+                IterableNotificationHelper.postNotificationOnDevice(context, notificationBuilder);
+            }
+        } catch (Exception e) {
+            IterableLogger.e(TAG, "Failed to post notification directly", e);
         }
-        return null;
     }
-}
+}

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

@@ -87,6 +87,20 @@ static boolean isEmptyBody(Bundle extras) {
         return instance.isEmptyBody(extras);
     }
 
+    /**
+     * Returns whether the notification payload includes an image attachment URL,
+     * meaning display requires a network image download (long-running work).
+     * @param extras what is inside the bundle
+     * @return if it has an attachment url
+     */
+    static boolean hasAttachmentUrl(Bundle extras) {
+        return instance.hasAttachmentUrl(extras);
+    }
+
+    static Bundle removePushImageFromBundle(Bundle extras) {
+        return instance.removePushImageFromBundle(extras);
+    }
+
     static Bundle mapToBundle(Map<String, String> map) {
         Bundle bundle = new Bundle();
         for (Map.Entry<String, String> entry : map.entrySet()) {
@@ -98,6 +112,11 @@ static Bundle mapToBundle(Map<String, String> map) {
     static class IterableNotificationHelperImpl {
 
         public IterableNotificationBuilder createNotification(Context context, Bundle extras) {
+            if (extras == null) {
+                IterableLogger.w(IterableNotificationBuilder.TAG, "Notification extras is null. Skipping.");
+                return null;
+            }
+
             String applicationName = context.getApplicationInfo().loadLabel(context.getPackageManager()).toString();
             String title = null;
             String notificationBody = null;
@@ -436,7 +455,7 @@ boolean isIterablePush(Bundle extras) {
 
         boolean isGhostPush(Bundle extras) {
             boolean isGhostPush = false;
-            if (extras.containsKey(IterableConstants.ITERABLE_DATA_KEY)) {
+            if (extras != null && extras.containsKey(IterableConstants.ITERABLE_DATA_KEY)) {
                 String iterableData = extras.getString(IterableConstants.ITERABLE_DATA_KEY);
                 IterableNotificationData data = new IterableNotificationData(iterableData);
                 isGhostPush = data.getIsGhostPush();
@@ -447,12 +466,50 @@ boolean isGhostPush(Bundle extras) {
 
         boolean isEmptyBody(Bundle extras) {
             String notificationBody = "";
-            if (extras.containsKey(IterableConstants.ITERABLE_DATA_KEY)) {
+            if (extras != null && extras.containsKey(IterableConstants.ITERABLE_DATA_KEY)) {
                 notificationBody = extras.getString(IterableConstants.ITERABLE_DATA_BODY, "");
             }
 
             return notificationBody.isEmpty();
         }
+
+        @Nullable
+        private JSONObject getIterableJsonFromBundle(Bundle extras) {
+            if (extras == null || !extras.containsKey(IterableConstants.ITERABLE_DATA_KEY)) {
+                return null;
+            }
+            try {
+                String iterableData = extras.getString(IterableConstants.ITERABLE_DATA_KEY);
+                return new JSONObject(iterableData);
+            } catch (Exception e) {
+                return null;
+            }
+        }
+
+        boolean hasAttachmentUrl(Bundle extras) {
+            JSONObject iterableJson = getIterableJsonFromBundle(extras);
+            if (iterableJson == null) {
+                return false;
+            }
+            String attachmentUrl = iterableJson.optString(IterableConstants.ITERABLE_DATA_PUSH_IMAGE, "");
+            return !attachmentUrl.isEmpty();
+        }
+
+        Bundle removePushImageFromBundle(Bundle extras) {
+            JSONObject iterableJson = getIterableJsonFromBundle(extras);
+            if (iterableJson == null) {
+                return extras;
+            }
+            try {
+                Bundle newExtras = new Bundle(extras);
+                iterableJson.remove(IterableConstants.ITERABLE_DATA_PUSH_IMAGE);
+                newExtras.putString(IterableConstants.ITERABLE_DATA_KEY, iterableJson.toString());
+                return newExtras;
+            } catch (Exception e) {
+                IterableLogger.e("IterableNotificationHelper", "Failed to remove push image from bundle", e);
+                return extras;
+            }
+        }
     }
 
     @Nullable

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

@@ -0,0 +1,80 @@
+package com.iterable.iterableapi;
+
+import android.content.Context;
+import android.os.Bundle;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import androidx.work.Data;
+import androidx.work.OneTimeWorkRequest;
+import androidx.work.OutOfQuotaPolicy;
+import androidx.work.WorkManager;
+
+import java.util.UUID;
+
+class IterableNotificationWorkScheduler {
+
+    private static final String TAG = "IterableNotificationWorkScheduler";
+
+    private final Context context;
+    private final WorkManager workManager;
+
+    interface SchedulerCallback {
+        void onScheduleSuccess(UUID workId);
+        void onScheduleFailure(Exception exception, Bundle notificationData);
+    }
+
+    IterableNotificationWorkScheduler(@NonNull Context context) {
+        this(context, WorkManager.getInstance(context));
+    }
+
+    @VisibleForTesting
+    IterableNotificationWorkScheduler(@NonNull Context context, @NonNull WorkManager workManager) {
+        this.context = context.getApplicationContext();
+        this.workManager = workManager;
+    }
+
+    void scheduleNotificationWork(
+            @NonNull Bundle notificationData,
+            @Nullable SchedulerCallback callback
+    ) {
+
+        try {
+            Data inputData = IterableNotificationWorker.createInputData(
+                    notificationData
+            );
+
+            OneTimeWorkRequest workRequest = new OneTimeWorkRequest.Builder(IterableNotificationWorker.class)
+                    .setInputData(inputData)
+                    .setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)
+                    .build();
+
+            workManager.enqueue(workRequest);
+
+            UUID workId = workRequest.getId();
+            IterableLogger.d(TAG, "Notification work scheduled: " + workId);
+
+            if (callback != null) {
+                callback.onScheduleSuccess(workId);
+            }
+
+        } catch (Exception e) {
+            IterableLogger.e(TAG, "Failed to schedule notification work", e);
+
+            if (callback != null) {
+                callback.onScheduleFailure(e, notificationData);
+            }
+        }
+    }
+
+    @VisibleForTesting
+    Context getContext() {
+        return context;
+    }
+
+    @VisibleForTesting
+    WorkManager getWorkManager() {
+        return workManager;
+    }
+}