BACK TO WORK

Array Launcher

Role
Android Engineer
Year
2025—PRESENT
Category
Product
[KOTLIN][JETPACK_COMPOSE][HILT][ROOM][CLEAN_ARCHITECTURE]

01 — The Idea

A phone's home screen fills up fast: rows of icons, red badges and a status bar full of notifications, each one asking for another tap.

Array Launcher is my answer to that, summed up by its welcome screen: "Your home, minus the noise." The homescreen holds the time and the apps you pick, and everything else waits a swipe away.

It is also a long-running engineering project. A launcher is the one app that is always open, so it has to start instantly, never lose the user's setup, and cope with every Android version and phone maker it runs on.

02 — Product

The launcher is three pages you swipe between.

  • Homescreen: a quiet widget (clock, date and battery, plus the weather, your next calendar event, what's playing and the next prayer time if you want them) above a short list of the apps you chose.
  • App drawer: every app, sorted by name, install date, last opened or size, filtered by category, with an alphabet index whose letters magnify under your finger. Any app can be renamed or hidden, and a long-press shows its shortcuts and today's screen time.
  • Notifications: with the filter on, new notifications collect on this page instead of the status bar, all day or only in the hours and days you set.

Around those three pages:

  • Focus sessions: tap Focus to start a 5 to 120 minute session. The homescreen clears to the clock, Do Not Disturb turns on, and every fourth session earns a long break.
  • Search that guesses well: names that start with what you type come first, initials such as gm find Google Maps, contacts and the web are one tap away, and a sum like 12*3+4 is answered in the results.
  • Make it yours: gestures, themes, wallpaper, fonts, icon shapes and icon packs, with every setting backed up and restored as a single JSON file.

The launcher is free, and Array Pro (yearly or a one-time purchase) adds extras such as weather, calendar, Focus, icon packs and renaming or hiding apps.

03 — Architecture

The app is split into 15 Gradle modules: one app module, shared core modules, and a domain and presentation module for each feature (home, app drawer, notifications, onboarding and settings).

+-----------------------------------------------+
|  :app                                         |
|  MainActivity · Navigation · Hilt · Services  |
+-----------------------------------------------+
|  :feature:*:presentation                      |
|  Compose screens · ViewModels · UI state      |
|  home · applist · notification · onboarding   |
+-----------------------------------------------+
|  :feature:*:domain + :core:domain             |
|  Use cases · Models · Repository contracts    |
|  Pure Kotlin, no Android classes              |
+-----------------------------------------------+
|  :core:data                                   |
|  Room · DataStore · System services · Weather |
+-----------------------------------------------+

Dependencies flow one way, from UI to ViewModel to use case to repository. Features never depend on each other: screens expose callbacks, and only the app module wires them to navigation. The theme, colours, fonts and icons live in a separate design-system module that no feature can reach back into.

04 — Engineering Decisions

Boundaries enforced by tests

Clean Architecture tends to erode one shortcut at a time. Here, the rules are checked by ArchUnit tests that run with every unit test build:

  • Presentation code may not touch the data layer.
  • ViewModels may call use cases only, never repositories.
  • A feature's domain builds on the core domain only.
  • The design system may not depend on any feature.

The core domain module is a plain JVM library, so Android classes don't even compile there. A violation fails the build instead of waiting for a code review to catch it.

Android behind interfaces

Launching apps, icon packs, notifications, wallpaper, fonts and the focus timer are interfaces in the domain layer, with Android implementations in the data layer. Use cases stay testable on the JVM, and version-specific Android code lives in one place per concern.

Local-first, private by default

Apps, notifications and settings are kept on the phone in Room and DataStore. The only network call is the weather, and the location sent for it is rounded to about a kilometre. Backups are a single JSON file written with kotlinx.serialization, so a whole setup moves to a new phone as one file.

A pure function for app list sync

The launcher keeps its own table of installed apps, because each row also carries what the user set: homescreen position, a custom name, hidden or pinned. A pure function compares the installed apps with the stored rows and returns a sync plan, which is written in a single transaction:

  • Rows match on package, activity and user profile.
  • A matched row keeps the user's settings and picks up the new label and category.
  • When an update renames an app's only launcher activity, the new row inherits the old row's settings.
  • Only rows that changed are written.

Sync runs on system app-change callbacks, debounced by 500 ms. Because the plan is pure Kotlin, its rules are covered by plain JVM unit tests, with no device needed.

05 — Engineering Challenges

Every Android version, every phone maker.

The launcher supports Android 8.0 through Android 16 (API 26 to 36), and many platform rules changed in between. A few that needed handling:

  • Android 14 blocks opening an activity from another app's notification unless the launcher opts in explicitly. Without that opt-in, tapping a collected notification did nothing.
  • Android 12 and up refuse to start a foreground service from the background, so the focus timer restarts itself on the next homescreen start if a launch is refused.
  • A coroutine delay doesn't count time while the phone sleeps, so the focus timer waits on the wall clock in steps of at most a second.
  • Some vivo phones freeze the launcher while it is out of sight, so calendar changes never arrive. The homescreen re-reads the calendar on every resume.

Owning the notification shade.

A notification listener service runs outside any screen. It decides which notifications to collect (this user's, clearable, not ongoing, not a group summary), stores them in Room, keeps each one's tap action, and removes it from the status bar. Homescreen badges then combine the live status bar list with the stored list, counting each notification once.

Work profiles.

Apps can exist in both a personal and a work profile. App rows are keyed per profile, a paused work profile prompts the user to turn it on instead of failing silently, and only the launcher's own profile's notifications are collected.

06 — Result

A complete, daily-driver Android launcher that:

  • Covers the homescreen, app drawer, search, notifications, focus sessions and full customisation
  • Runs on Android 8.0 through 16, with documented workarounds for version and manufacturer quirks
  • Has architecture rules that the build enforces, not just a convention people have to remember
  • Is independently designed, built and maintained, from the first commit in January 2025 to version 1.0 in Google Play testing in October 2026

07 — Technologies

KOTLIN                  Primary language
JETPACK COMPOSE         The whole UI, with Material 3
HILT                    Dependency injection across modules
ROOM                    Apps and notifications, on the phone
DATASTORE               Settings, focus state and Pro status
COROUTINES + FLOW       Async work and reactive UI state
KOTLINX.SERIALIZATION   Backup and restore as one JSON file
OPENWEATHER             Weather, with location rounded to ~1 km
ARCHUNIT                Tests that keep each layer in its lane
GRADLE CONVENTIONS      Shared build logic for every module