SmsForwarder

Why I built it

I needed alert text messages forwarded from one phone to others. There are ready-made SMS forwarding apps for this, but none of them were good enough: they were bloated, they showed ads, and some of them sent the same message more than once. So I built my own.

What it does

SmsForwarder runs on an Android phone and listens for incoming messages. When an alert arrives, it doesn’t forward the raw text. It parses the message into its parts (task code, priority, time, address, units and details), translates the numeric task code into a readable description, highlights the units I’ve chosen, and adds a Google Maps link to the address. Then it sends that summary by SMS to the recipients set in the app.

A few rules keep it predictable:

• Each alert is forwarded once. Duplicates were one of the reasons I built it.
• Old alerts are skipped. Anything older than 10 minutes isn’t forwarded.
• Every send is tracked. The history shows each alert and whether the send to each recipient succeeded.
• History writes are serialized, so two alerts arriving close together can’t overwrite each other’s status.

Recipients, the units to highlight, and whether to include the map link and the unit list are all settings in the app, so changing them doesn’t need a new build.

How it works

A BroadcastReceiver picks up incoming SMS and hands them to a foreground service, which keeps the app alive in the background and does the parsing, formatting and sending through SmsManager. The send result for each recipient comes back through a broadcast and updates the history, which the Jetpack Compose UI shows live.

Some addresses don’t geocode well from the street address alone, so for those the app uses building-level coordinates to put the map link on the right building.

The parser has unit tests for single messages, bulk runs and the stale-alert rule. The test fixtures are synthetic: real place names, made-up incidents.

Getting past Android’s SMS limit

Android throttles how many text messages an app can send in a rolling window, and once the cap is hit it shows a “sending a large number of SMS messages” confirmation that someone has to tap. The defaults vary by Android version and manufacturer, commonly around 30 messages per 30 to 60 minutes. Forwarding a burst of alerts to several recipients trips that quickly.

The way around it would have been to make SmsForwarder the phone’s default messaging app, and I didn’t want that. It turns out the limit is just two global settings, and adb shell runs as the shell user, which is allowed to change them, so no root is needed:

# Read the current values (null means the framework default is in effect)
adb shell settings get global sms_outgoing_check_max_count
adb shell settings get global sms_outgoing_check_interval_ms

# Effectively remove the limit: a huge count over a 1 ms window
adb shell settings put global sms_outgoing_check_max_count 1000000
adb shell settings put global sms_outgoing_check_interval_ms 1

# Restore the Android defaults
adb shell settings delete global sms_outgoing_check_max_count
adb shell settings delete global sms_outgoing_check_interval_ms

The change survives reboots until you delete it. It also weakens a guard that exists to stop abuse, so it only belongs on a phone you control and use for exactly this.

Status

Version 1.2.0 (June 2026). It runs on an Android phone.

Tech

• Kotlin, Jetpack Compose
• Android SMS APIs: BroadcastReceiver, SmsManager
• Foreground service
• ADB (settings for the SMS limit)
• JUnit