Memoize device template to improve rule evaluation performance

[ianrumac]

Changes in this pull request

• Memoizes the device template used for audience-filter evaluation and paywall templating. The template is now rebuilt only when one of its mutable inputs (identity, entitlements, subscription status, etc.) changes, rather than on every rule evaluation.

• Separates volatile and stable template fields:

  • Stable fields (identity, device info, entitlements) are cached and reused
  • Volatile fields (time-derived values like utcDateTime, daysSinceLastPaywallView) are recomputed and overlaid on cache hits
  • This ensures time-sensitive fields stay current while avoiding expensive rebuilds

• Optimizes property access:

  • Converts frequently-accessed properties (appVersion, vendorId, deviceId, kotlinVersion, etc.) to lazy-initialized values
  • Caches PowerManager system service lookup
  • Consolidates date formatting logic into a single volatileTemplateFields() function

• Refactors template building:

  • Extracts buildDeviceTemplate() method for clarity
  • Introduces templateFingerprint() to detect when cache invalidation is needed
  • Adds VolatileTemplateFields data class to manage time-derived values
  • Uses AtomicReference for thread-safe cache management

• Removes duplicate code:

  • Eliminates redundant daysSinceLastPaywallView and minutesSinceLastPaywallView properties
  • Consolidates date/time formatting properties into a single computation

• Adds comprehensive test coverage (DeviceHelperMemoizationTest):

  • Verifies template is memoized when inputs don't change
  • Confirms cache invalidation on identity, entitlements, and platform wrapper changes
  • Validates time-derived fields are overlaid fresh on cache hits
  • Tests null handling for optional time-since fields

Checklist

• All unit tests pass (added DeviceHelperMemoizationTest with 5 test cases)
• Existing DeviceTemplateTest updated to verify toDictionary() compatibility
• I added an entry to the CHANGELOG.md for this enhancement
• Code follows existing patterns (lazy initialization, coroutine usage, error handling)

Performance Impact

This change significantly reduces CPU and memory overhead during rule evaluation:

• Template building involves ~55 field accesses and JSON serialization
• With memoization, this is skipped on cache hits (the common case)
• Time-derived fields are computed efficiently in a single pass rather than individually
• Fingerprint comparison is O(1) in-memory operation vs. full template rebuild