Doc Moates Apps
Native Android · Adaptive UI

Mail+

A clean, focused Gmail client that adapts to the device in your hand — bottom navigation on a phone, a real list-detail two-pane on a foldable or a phone running a desktop mode, hinge-aware in table-top mode, and a home-screen widget that lets you triage from the launcher.

All features → Coming to Google Play
Android phones Foldables Desktop mode Android tablets
M
3
Form factors
100%
Jetpack Compose
Gmail API
Real integration
Material 3
+ dynamic color

The pitch

One app, every screen you actually use.

Most email apps were designed for a phone and stretched onto a tablet. Mail+ was designed the other way around — start with the canvas a foldable gives you when it's open, then collapse it gracefully when you close the device. The same Compose UI handles a regular phone, a foldable open in book mode, and a freeform desktop-mode window without forking the code.

“The first email client I've used on a foldable that doesn't feel like it's pretending to be a phone.” — Designed for big screens, polished for small ones.

Features

Everything Mail+ does today

Gmail integration that's actually Gmail

Not a wrapper around a web view — a native Gmail client built on the Gmail REST API.

  • Google OAuth sign-in with token refresh handled in the background.
  • Gmail v1 REST API for threads, messages, labels, send, modify, and trash operations.
  • Multi-label awareness — the same message can live under Inbox, Starred, and a custom label, and read state stays consistent across every view.
  • Parallel API calls for first-paint speed — label list and unread counts fetch concurrently while the inbox loads.
  • Cache-first loading via SharedPreferences-backed per-label caches, so the inbox appears instantly and syncs in the background.
  • Graceful degradation — when the network is flaky, cached state stays on screen instead of clearing it out.

Adaptive layout, three form factors

Width-aware navigation and a list-detail scaffold that does the right thing automatically.

  • Compact (phone, foldable cover screen): bottom navigation bar, single-pane navigation, thread tap opens a new screen.
  • Medium (small tablet, half-open foldable portrait): navigation rail, single-pane.
  • Expanded (foldable unfolded, desktop mode, tablet landscape): permanent navigation drawer, two-pane list-detail with a ~40/60 split.
  • Smooth pane transitions via NavigableListDetailPaneScaffold — Compose handles the choreography.
  • Compose overlay replaces the detail pane on expanded screens and collapses back when you send or discard.
  • One codebase — no separate phone/tablet activities, no XML layouts, no sw600dp resource forks.

Foldables and desktop mode as first-class targets

Hinge-aware layouts, free-form windows, and a UI that respects the seam.

  • Foldable posture detection via Jetpack WindowManager — the app knows when you're flat, half-open, book mode, or table-top.
  • Table-top mode: controls on the bottom pane, content on top — perfect for reading email at a desk.
  • Book mode: two-pane content that respects isSeparating so nothing important sits under the hinge.
  • Desktop mode: resizeableActivity=true and a <layout> manifest tag — the app can be resized to any window dimensions and stays interactive when you dock to an external display.
  • Pointer + keyboard friendly — built for the mouse and keyboard you plug into a desktop dock.
  • Cover screen on a foldable: the compact layout handles the outer display perfectly.

Reading experience

Email you'd actually want to read on a big screen.

  • HTML and plain-text rendering with embedded WebView, scripting disabled, image loading isolated.
  • Pinch-to-zoom on every message, plus built-in zoom controls.
  • Drawer-swipe is disabled while reading — your zoom gesture always wins instead of opening the side drawer accidentally.
  • Sender avatars generated from a hash of the sender's address, with a deterministic color from the palette so the same sender looks the same every time.
  • Smart timestamps — same-day messages show h:mm a, older messages show MMM d.
  • Thread headers — Message-ID and References parsed so conversations stay grouped.

Compose, reply, and forward

A real composer, not a popup.

  • Full composition surface with To, Cc, Subject, and body — fields that feel like fields, not floating placeholders.
  • Reply, Reply All, and Forward with automatic quoting (“On [date], [sender] wrote:”).
  • Multipart MIME send — every message goes out as plain text + HTML alternative so it lands cleanly in any client.
  • Conversation threading — In-Reply-To and References headers set automatically so replies group with the original thread.
  • Send progress indicator with a spinner so you know the API actually accepted the message.
  • Drafts kept in memory while composing, so accidental navigation doesn't lose the message.

Triage and management

All the daily verbs.

  • Archive — removes from Inbox, preserves under every other label the message belongs to.
  • Delete — moves to Trash and clears the message from all cached views.
  • Mark as read / unread — updates the Gmail server and every local cache in one shot.
  • Optimistic UI — actions reflect immediately; the API call happens in the background.
  • Bold unread rows with bold sender name + bold subject so unread state is unmissable at a glance.
  • Selection highlight on the detail pane (expanded layout) so you always know which message you're reading.

Search

Find what you need without leaving the current label.

  • Full-text search across sender, subject, and snippet within the current view.
  • Instant filtering — results update as you type, no submit button.
  • Case-insensitive matching, including across Unicode.
  • Stays in context — search inside Inbox stays in Inbox; search inside a custom label scopes to that label.

Labels and organization

Gmail's labels, treated as the first-class concept they are.

  • System labels first: Inbox, Starred, Snoozed, Sent, Drafts, Important, All Mail, Spam, Trash.
  • Unlimited user labels with full CRUD — create, rename, recolor, delete.
  • Nested hierarchy — Gmail's Parent/Child naming is rendered as a hierarchy in the drawer.
  • Color-coded labels with user-assigned hex colors rendered as dots; a calm fallback palette when nothing's set.
  • Alphabetical sort for user labels so the same label is always in the same place.
  • Per-label unread badges shown in the drawer and updated live as messages are read.

Favorites home-screen widget

Triage from the launcher.

  • Glance-based widget using the new Compose-style widget framework, not legacy RemoteViews.
  • Multi-section — Mail, Calendar, Contacts, Tasks, and a morning briefing all share one widget.
  • Section switcher built into the widget header — tap a tab to swap content without leaving the launcher.
  • Unread message list with sender avatar, subject, and snippet.
  • Inline detail preview — tap a message in the widget to expand its snippet, date, and sender right in place.
  • State persistence — the widget remembers what you were viewing across launches.

Settings and account

Configuration that respects you.

  • Manage labels screen with nested editing and color assignment.
  • Portal login for xMethod account, separate from Google OAuth — two independent identities.
  • Sign out from the drawer, cleanly clearing tokens and caches.
  • Per-identity signatures (UI scaffold in place, full editor on the roadmap).
  • Server-side filter rules (UI scaffold in place, full editor on the roadmap).

Design and theming

Material 3 done with a calm visual voice.

  • Material You dynamic color on Android 12+ — Mail+ picks up your wallpaper palette.
  • Custom warm palette as the fallback — beige background #FAF6F1, dark cocoa ink #3D2F24, sage and water-blue accents.
  • Serif headlines for long-form reading; system sans for UI chrome.
  • Outlined icon set for clarity at small sizes and a quieter visual weight.
  • Edge-to-edge insets with proper window-inset handling on gesture-nav devices.
  • Hierarchical spacing — 12–16dp rhythm across the whole app, no ad-hoc paddings.

Architecture and performance

Modern Android, built to last.

  • 100% Kotlin and Jetpack Compose — no Views, no Fragments, no XML layouts.
  • Hilt dependency injection wired through repositories and ViewModels.
  • Gradle convention plugins (xm17.android.library, xm17.android.compose, xm17.hilt) keep every module's build script three lines long.
  • Modular by feature — feature/email is independently buildable, with its own data layer, theme, and screens.
  • Coroutines + Flow for async work; everything respects lifecycle scopes.
  • OkHttp client reuse and parallel coroutine fetches keep cold-start time low.

Roadmap

What's coming next

  • Snooze with custom date/time picker

    Backend already supports Snoozed label — UI date picker in active development.

  • Server-side filter rules editor

    Manage Gmail's filter rules from inside the app — backend wired, UI in design.

  • Signature editor

    Per-identity signatures with rich-text formatting.

  • Keyboard shortcuts for desktop mode

    Gmail-style hotkeys (j/k to move, e to archive, r to reply) for pointer-and-keyboard use on a docked phone or tablet.

  • Splash screen

    Branded launch via androidx.core:core-splashscreen.

Mail+ ships through Google Play.

A direct-to-consumer release on the Play Store — no enterprise contracts, no licensing. Install it like any other Android app and sign in with your Google account.

Coming soon to Google Play
← Back to all apps