Efficient Email Sync Strategy for an Android App – Optimizing for Battery, Network, and Consistency

Question

I am designing an Android email application and need an efficient synchronization strategy that balances battery life, network usage, and consistency while ensuring offline support.

Current Approach:

Fetching Emails:

• On app launch, fetch emails via a REST API and store them in an encrypted Room database (SQLCipher), which serves as the single source of truth for the UI.
• Store an ETag in EncryptedSharedPreferences to track the last synced state and request only new emails.
• On subsequent app launches, send the stored ETag in the request.
  • If new emails are available, update/add the corresponding rows in the database.
  • If no updates exist, the API returns 304 Not Modified to avoid unnecessary data transfer.

Handling New Emails:

• Use FCM push notifications to notify the app when a new email arrives (whether the app is open or closed).
• The FCM payload contains the ETag, allowing the app to compare it with the stored ETag.
• If the ETag differs, fetch new emails via REST (on notification click or when app is in foreground) and update the local database.

Offline Support & Syncing User Actions:

• Actions (e.g., marking an email read) are stored in a Sync DB when offline.
• WorkManager syncs pending actions with the server when the network is available.

Conflict Resolution:

• Last-write-wins (LWW) strategy is used for conflicts when the same email is modified on multiple devices.
• Concern: Device timestamps are unreliable, so conflicts must be resolved via a server-side versioning system.

Trade-offs & Open Questions:

Advantages:

• Reduces battery consumption compared to WebSockets or long polling.
• Supports offline access with local storage.
• Reduces unnecessary API calls using ETag-based incremental sync.

Challenges:

1. FCM latency (can be a few seconds) compared to WebSockets.
2. Alternative approaches? Are there better ways to optimize sync while keeping battery/network usage low?

Would this approach be considered a best practice for an email app, or are there alternative strategies to improve efficiency further?

P.S. I am aware of IMAP, but based on my research, it is more complex to implement and maintaining a persistent connection drains battery.