Reevaluation Changes for core Launch Rules Engine

code/core/api/core.api

@@ -323,14 +323,18 @@ public final class com/adobe/marketing/mobile/WrapperType : java/lang/Enum {
 public final class com/adobe/marketing/mobile/launch/rulesengine/LaunchRule : com/adobe/marketing/mobile/rulesengine/Rule {
 	public static final field $stable I
 	public fun <init> (Lcom/adobe/marketing/mobile/rulesengine/Evaluable;Ljava/util/List;)V
+	public fun <init> (Lcom/adobe/marketing/mobile/rulesengine/Evaluable;Ljava/util/List;Lcom/adobe/marketing/mobile/launch/rulesengine/RuleMeta;)V
+	public synthetic fun <init> (Lcom/adobe/marketing/mobile/rulesengine/Evaluable;Ljava/util/List;Lcom/adobe/marketing/mobile/launch/rulesengine/RuleMeta;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
 	public final fun component1 ()Lcom/adobe/marketing/mobile/rulesengine/Evaluable;
 	public final fun component2 ()Ljava/util/List;
-	public final fun copy (Lcom/adobe/marketing/mobile/rulesengine/Evaluable;Ljava/util/List;)Lcom/adobe/marketing/mobile/launch/rulesengine/LaunchRule;
-	public static synthetic fun copy$default (Lcom/adobe/marketing/mobile/launch/rulesengine/LaunchRule;Lcom/adobe/marketing/mobile/rulesengine/Evaluable;Ljava/util/List;ILjava/lang/Object;)Lcom/adobe/marketing/mobile/launch/rulesengine/LaunchRule;
+	public final fun component3 ()Lcom/adobe/marketing/mobile/launch/rulesengine/RuleMeta;
+	public final fun copy (Lcom/adobe/marketing/mobile/rulesengine/Evaluable;Ljava/util/List;Lcom/adobe/marketing/mobile/launch/rulesengine/RuleMeta;)Lcom/adobe/marketing/mobile/launch/rulesengine/LaunchRule;
+	public static synthetic fun copy$default (Lcom/adobe/marketing/mobile/launch/rulesengine/LaunchRule;Lcom/adobe/marketing/mobile/rulesengine/Evaluable;Ljava/util/List;Lcom/adobe/marketing/mobile/launch/rulesengine/RuleMeta;ILjava/lang/Object;)Lcom/adobe/marketing/mobile/launch/rulesengine/LaunchRule;
 	public fun equals (Ljava/lang/Object;)Z
 	public final fun getCondition ()Lcom/adobe/marketing/mobile/rulesengine/Evaluable;
 	public final fun getConsequenceList ()Ljava/util/List;
 	public fun getEvaluable ()Lcom/adobe/marketing/mobile/rulesengine/Evaluable;
+	public final fun getMeta ()Lcom/adobe/marketing/mobile/launch/rulesengine/RuleMeta;
 	public fun hashCode ()I
 	public fun toString ()Ljava/lang/String;
 }
@@ -341,6 +345,7 @@ public class com/adobe/marketing/mobile/launch/rulesengine/LaunchRulesEngine {
 	public fun evaluateEvent (Lcom/adobe/marketing/mobile/Event;)Ljava/util/List;
 	public fun processEvent (Lcom/adobe/marketing/mobile/Event;)Lcom/adobe/marketing/mobile/Event;
 	public fun replaceRules (Ljava/util/List;)V
+	public fun setRuleReevaluationInterceptor (Lcom/adobe/marketing/mobile/launch/rulesengine/RuleReevaluationInterceptor;)V
 }
 
 public final class com/adobe/marketing/mobile/launch/rulesengine/RuleConsequence {
@@ -359,6 +364,24 @@ public final class com/adobe/marketing/mobile/launch/rulesengine/RuleConsequence
 	public fun toString ()Ljava/lang/String;
 }
 
+public final class com/adobe/marketing/mobile/launch/rulesengine/RuleMeta {
+	public static final field $stable I
+	public fun <init> ()V
+	public fun <init> (Z)V
+	public synthetic fun <init> (ZILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun component1 ()Z
+	public final fun copy (Z)Lcom/adobe/marketing/mobile/launch/rulesengine/RuleMeta;
+	public static synthetic fun copy$default (Lcom/adobe/marketing/mobile/launch/rulesengine/RuleMeta;ZILjava/lang/Object;)Lcom/adobe/marketing/mobile/launch/rulesengine/RuleMeta;
+	public fun equals (Ljava/lang/Object;)Z
+	public final fun getReEvaluate ()Z
+	public fun hashCode ()I
+	public fun toString ()Ljava/lang/String;
+}
+
+public abstract interface class com/adobe/marketing/mobile/launch/rulesengine/RuleReevaluationInterceptor {
+	public abstract fun onReevaluationTriggered (Lcom/adobe/marketing/mobile/Event;Ljava/util/List;Lcom/adobe/marketing/mobile/AdobeCallback;)V
+}
+
 public class com/adobe/marketing/mobile/launch/rulesengine/download/RulesLoadResult {
 	public fun <init> (Ljava/lang/String;Lcom/adobe/marketing/mobile/launch/rulesengine/download/RulesLoadResult$Reason;)V
 	public fun getData ()Ljava/lang/String;

code/core/src/main/java/com/adobe/marketing/mobile/internal/CoreConstants.kt

@@ -13,7 +13,7 @@ package com.adobe.marketing.mobile.internal
 
 internal object CoreConstants {
     const val LOG_TAG = "MobileCore"
-    const val VERSION = "3.5.0"
+    const val VERSION = "3.5.1"
 
     object EventDataKeys {
         /**

code/core/src/main/java/com/adobe/marketing/mobile/launch/rulesengine/LaunchRule.kt

@@ -19,9 +19,14 @@ import com.adobe.marketing.mobile.rulesengine.Rule
  *
  * @property condition an object of [Evaluable]
  * @property consequenceList a list of [RuleConsequence] objects
- * @constructor Constructs a new [LaunchRule]
+ * @property meta an object containing relevant meta data regarding the rule
+ * @constructor Constructs a new [LaunchRule] (Optional)
  */
-data class LaunchRule(val condition: Evaluable, val consequenceList: List<RuleConsequence>) : Rule {
+data class LaunchRule @JvmOverloads constructor(
+    val condition: Evaluable,
+    val consequenceList: List<RuleConsequence>,
+    val meta: RuleMeta = RuleMeta()
+) : Rule {
     override fun getEvaluable(): Evaluable {
         return condition
     }

code/core/src/main/java/com/adobe/marketing/mobile/launch/rulesengine/LaunchRulesConsequence.kt

@@ -69,6 +69,7 @@ internal class LaunchRulesConsequence(
         private const val CONSEQUENCE_EVENT_HISTORY_OPERATION_INSERT_IF_NOT_EXISTS =
             "insertIfNotExists"
         private const val ASYNC_TIMEOUT = 1000L
+        private val REEVALUABLE_CONSEQUENCE_TYPES = setOf<String>(CONSEQUENCE_TYPE_SCHEMA)
     }
 
     /**
@@ -170,6 +171,36 @@ internal class LaunchRulesConsequence(
         return processedConsequences
     }
 
+    fun getReevaluableRules(rules: MutableList<LaunchRule>): MutableList<LaunchRule?> {
+        val revaluableRules: MutableList<LaunchRule?> = java.util.ArrayList<LaunchRule?>()
+        for (rule in rules) {
+            if (rule.meta.reEvaluate && rule.hasReevaluableSupportedConsequence) {
+                revaluableRules.add(rule)
+            }
+        }
+        return revaluableRules
+    }
+
+    fun getRulesToHoldForReevaluation(rules: MutableList<LaunchRule>): MutableList<LaunchRule?> {
+        val rulesToHold: MutableList<LaunchRule?> = ArrayList()
+        for (rule in rules) {
+            if (rule.hasReevaluableSupportedConsequence) {
+                rulesToHold.add(rule)
+            }
+        }
+        return rulesToHold
+    }
+
+    private val LaunchRule.hasReevaluableSupportedConsequence: Boolean
+        get() {
+            for (consequence in this.consequenceList) {
+                if (REEVALUABLE_CONSEQUENCE_TYPES.contains(consequence.type)) {
+                    return true
+                }
+            }
+            return false
+        }
+
     /**
      * Replace tokens inside the provided [RuleConsequence] with the right value
      *

code/core/src/main/java/com/adobe/marketing/mobile/launch/rulesengine/LaunchRulesEngine.java

@@ -27,6 +27,8 @@
 
 public class LaunchRulesEngine {
 
+    private RuleReevaluationInterceptor reevaluationInterceptor;
+
     @VisibleForTesting static final String RULES_ENGINE_NAME = "name";
     private final String name;
     private final RulesEngine<LaunchRule> ruleRulesEngine;
@@ -61,6 +63,15 @@ public LaunchRulesEngine(@NonNull final String name, @NonNull final ExtensionApi
         this.ruleRulesEngine = ruleEngine;
     }
 
+    /**
+     * Sets the {@link RuleReevaluationInterceptor} for this {@link LaunchRulesEngine}.
+     *
+     * @param interceptor the interceptor to be set.
+     */
+    public void setRuleReevaluationInterceptor(final RuleReevaluationInterceptor interceptor) {
+        this.reevaluationInterceptor = interceptor;
+    }
+
     /**
      * Set a new set of rules, the new rules replace the current rules.
      *
@@ -102,20 +113,19 @@ public Event processEvent(@NonNull final Event event) {
             throw new IllegalArgumentException("Cannot evaluate null event.");
         }
 
-        final List<LaunchRule> matchedRules =
-                ruleRulesEngine.evaluate(new LaunchTokenFinder(event, extensionApi));
-
         // if initial rule set has not been received, cache the event to be processed
         // when rules are set
         if (!initialRulesReceived) {
             handleCaching(event);
         }
-        return launchRulesConsequence.process(event, matchedRules);
+
+        return processAndIntercept(event);
     }
 
     /**
      * Evaluates the supplied event against the all current rules and returns the {@link
-     * RuleConsequence}'s from the rules that matched the supplied event.
+     * RuleConsequence}'s from the rules that matched the supplied event. This method is synchronous
+     * and does not trigger any re-evaluation interceptors.
      *
      * @param event the event to be evaluated
      * @return a {@code List<RuleConsequence>} that match the supplied event.
@@ -125,13 +135,50 @@ public List<RuleConsequence> evaluateEvent(@NonNull final Event event) {
             throw new IllegalArgumentException("Cannot evaluate null event.");
         }
 
-        final List<LaunchRule> matchedRules =
-                ruleRulesEngine.evaluate(new LaunchTokenFinder(event, extensionApi));
+        final LaunchTokenFinder tokenFinder = new LaunchTokenFinder(event, extensionApi);
+        final List<LaunchRule> matchedRules = ruleRulesEngine.evaluate(tokenFinder);
 
         // get token replaced consequences
         return launchRulesConsequence.evaluate(event, matchedRules);
     }
 
+    private Event processAndIntercept(final Event event) {
+        final LaunchTokenFinder tokenFinder = new LaunchTokenFinder(event, extensionApi);
+        final List<LaunchRule> matchedRules = ruleRulesEngine.evaluate(tokenFinder);
+
+        // If no interceptor is set, process consequences immediately.
+        if (reevaluationInterceptor == null) {
+            return launchRulesConsequence.process(event, matchedRules);
+        }
+
+        final List<LaunchRule> revaluableRules =
+                launchRulesConsequence.getReevaluableRules(matchedRules);
+        if (revaluableRules.isEmpty()) {
+            return launchRulesConsequence.process(event, matchedRules);
+        }
+
+        final List<LaunchRule> rulesToHold =
+                launchRulesConsequence.getRulesToHoldForReevaluation(matchedRules);
+        final ArrayList<LaunchRule> rulesToProcess = new ArrayList<>(matchedRules);
+        rulesToProcess.removeAll(rulesToHold);
+        Event processedEvent = launchRulesConsequence.process(event, rulesToProcess);
+        reevaluationInterceptor.onReevaluationTriggered(
+                processedEvent,
+                revaluableRules,
+                (success) -> {
+                    // After the interceptor has updated the rules, re-evaluate and process
+                    // consequences. If update is not success intercepted rules are not
+                    // processed
+                    if (success) {
+                        final ArrayList<LaunchRule> newlyMatchedRules =
+                                new ArrayList<>(ruleRulesEngine.evaluate(tokenFinder));
+                        newlyMatchedRules.removeAll(rulesToProcess);
+                        launchRulesConsequence.process(processedEvent, newlyMatchedRules);
+                    }
+                });
+        return processedEvent;
+    }
+
     List<LaunchRule> getRules() {
         return ruleRulesEngine.getRules();
     }
@@ -142,14 +189,14 @@ int getCachedEventCount() {
     }
 
     private void reprocessCachedEvents() {
-        for (Event cachedEvent : cachedEvents) {
-            final List<LaunchRule> matchedRules =
-                    ruleRulesEngine.evaluate(new LaunchTokenFinder(cachedEvent, extensionApi));
-            launchRulesConsequence.process(cachedEvent, matchedRules);
-        }
-        // clear cached events and set the flag to indicate that rules were set at least once
+        // To avoid ConcurrentModificationException, we process a copy of the cached events.
+        final List<Event> eventsToReprocess = new ArrayList<>(cachedEvents);
         cachedEvents.clear();
-        initialRulesReceived = true;
+        initialRulesReceived = true; // Set before processing to prevent re-caching
+
+        for (final Event cachedEvent : eventsToReprocess) {
+            processEvent(cachedEvent);
+        }
     }
 
     private void handleCaching(final Event event) {

code/core/src/main/java/com/adobe/marketing/mobile/launch/rulesengine/RuleMeta.kt

@@ -0,0 +1,23 @@
+/*
+  Copyright 2022 Adobe. All rights reserved.
+  This file is licensed to you under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License. You may obtain a copy
+  of the License at http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing, software distributed under
+  the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+  OF ANY KIND, either express or implied. See the License for the specific language
+  governing permissions and limitations under the License.
+*/
+
+package com.adobe.marketing.mobile.launch.rulesengine
+
+/**
+ * The data class representing a rule's consequence object
+ *
+ * @property reEvaluate the flag reEvaluate for sensitive rules
+ * @constructor Constructs a new [RuleMeta]
+ */
+
+data class RuleMeta(
+    val reEvaluate: Boolean = false,
+)

code/core/src/main/java/com/adobe/marketing/mobile/launch/rulesengine/RuleReevaluationInterceptor.kt

@@ -0,0 +1,28 @@
+/*
+  Copyright 2026 Adobe. All rights reserved.
+  This file is licensed to you under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License. You may obtain a copy
+  of the License at http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing, software distributed under
+  the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+  OF ANY KIND, either express or implied. See the License for the specific language
+  governing permissions and limitations under the License.
+*/
+
+package com.adobe.marketing.mobile.launch.rulesengine
+
+import com.adobe.marketing.mobile.AdobeCallback
+import com.adobe.marketing.mobile.Event
+
+/**
+ * An interface for an interceptor that is triggered when a [LaunchRule] with the
+ * re-evaluation flag is triggered. The interceptor is responsible for updating the rules and
+ * invoking the [AdobeCallback] when complete. success is passed as a boolean value.
+ */
+interface RuleReevaluationInterceptor {
+    fun onReevaluationTriggered(
+        event: Event?,
+        revaluableRules: List<LaunchRule?>?,
+        callback: AdobeCallback<Boolean>?
+    )
+}

code/core/src/main/java/com/adobe/marketing/mobile/launch/rulesengine/json/JSONMeta.kt

@@ -0,0 +1,54 @@
+/*
+  Copyright 2022 Adobe. All rights reserved.
+  This file is licensed to you under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License. You may obtain a copy
+  of the License at http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing, software distributed under
+  the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+  OF ANY KIND, either express or implied. See the License for the specific language
+  governing permissions and limitations under the License.
+*/
+
+package com.adobe.marketing.mobile.launch.rulesengine.json
+
+import com.adobe.marketing.mobile.launch.rulesengine.RuleMeta
+import org.json.JSONObject
+
+/**
+ * Generic utility to parse a meta object from JSON for rules engine.
+ *
+ * This class is responsible for extracting meta information from a JSON object.
+ * Currently, it only parses the `reEvaluate` flag, but it is designed to be extended
+ * in the future to support additional meta keys as needed.
+ *
+ * Example of a meta JSON object:
+ * ```json
+ * {
+ *   "reEvaluate": true
+ * }
+ * ```
+ *
+ * Future meta keys can be added to this class as requirements evolve.
+ */
+internal class JSONMeta private constructor(
+    private val reEvaluate: Boolean,
+) {
+    companion object {
+        private const val KEY_REEVALUATE = "reEvaluate"
+        operator fun invoke(jsonObject: JSONObject?): JSONMeta {
+            return JSONMeta(
+                jsonObject?.optBoolean(KEY_REEVALUATE, false) ?: false
+            )
+        }
+    }
+
+    /**
+     * Converts this object into a validated [RuleMeta].
+     *
+     * @return a valid [RuleMeta] or `null` if any validation check fails
+     */
+    @JvmSynthetic
+    internal fun toMeta(): RuleMeta {
+        return RuleMeta(reEvaluate)
+    }
+}