DEV Community: 55tarkun

How I Built an Android “Don’t Touch” Mode That Survives Flutter Process Death

55tarkun — Sun, 09 Aug 2026 11:10:58 +0000

“I will not touch my phone for 30 minutes” often lasts until the next unconscious unlock.

I built an Android-only “Don’t Touch Mode” for Yominder. The user chooses a duration. Every time they unlock the phone during that session, one of 64 character lines plays locally. It does not block access; it makes the action noticeable.

The hard part was not detecting a tap. It was keeping the behavior alive when the Flutter process was gone, stopping at the correct time, and restoring state after a reboot.

Product behavior

Starts now for 30 min, 1h, 1.5h, 2h, 3h, 6h, 12h, or 1 day
Reacts on every unlock; cooldown is zero
Randomly chooses from eight characters and eight lines each
Stops automatically at an absolute end time
Can be stopped immediately from its foreground notification
Does not lock the user out of the phone
Android only

The last constraint is deliberate. Emergency access matters more than making the focus mechanism impossible to bypass.

Why `ACTION_USER_PRESENT`

SCREEN_ON fires when the display turns on, including cases where the user only checks the time. The behavior I wanted was closer to “the user authenticated and entered the phone.” Android's ACTION_USER_PRESENT is the better event for that definition.

The foreground service dynamically registers the receiver:

val newReceiver = object : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        if (intent.action == Intent.ACTION_USER_PRESENT) {
            onUnlocked()
        }
    }
}

registerReceiver(
    newReceiver,
    IntentFilter(Intent.ACTION_USER_PRESENT)
)

I rejected an Accessibility Service approach. It would request a much stronger capability than the feature needs and add store-policy and user-trust costs.

Split ownership at the process boundary

Flutter owns configuration and audio preparation. Android owns time-critical and process-independent behavior.

Flutter settings --MethodChannel--> Android configuration
                                      |          |
                                      |          +--> AlarmManager stop alarm
                                      v
                               Foreground Service
                                      |
                                      v
                             ACTION_USER_PRESENT
                                      |
                                      v
Pre-generated local audio --> Kotlin MediaPlayer

Starting Flutter on unlock would add latency and fail when the process cannot be launched quickly. The Kotlin service plays a pre-generated local file directly with MediaPlayer.

mediaPlayer = MediaPlayer().apply {
    setDataSource(path)
    setOnCompletionListener { player -> player.release() }
    prepare()
    start()
}

No network call occurs at unlock time. That makes the interaction fast and independent of connectivity.

Why not a Dart timer?

A Dart timer is not a durable scheduler. The app can be killed, the isolate can stop, and the device can reboot.

The app stores an absolute end timestamp and schedules a one-shot Android alarm:

alarmManager.setExactAndAllowWhileIdle(
    AlarmManager.RTC_WAKEUP,
    endAtMillis,
    stopPendingIntent
)

If exact-alarm permission is unavailable, the implementation catches the security failure and falls back to setAndAllowWhileIdle. The tradeoff is a potentially later stop instead of a crash.

Restore from facts, not transient state

The saved facts are: enabled, absolute end time, and local audio paths. On boot, app replacement, time change, timezone change, or exact-alarm permission change, the receiver reevaluates those facts.

Disabled --select duration--> Active
Active   --unlock-----------> Active (play a random line)
Active   --end alarm--------> Disabled
Active   --notification-----> Disabled
Active   --reboot, time left> Active
Active   --restore, expired-> Disabled

The session is one-shot rather than a repeating daily schedule. That reduces ambiguous state and makes “now for 30 minutes” easy to recover.

The foreground notification is part of the UX

Android requires a visible notification for the service. Instead of treating it as noise, the app uses it to show that the mode is active and provide an escape hatch.

This matters because the mode is intentionally annoying. A user who enabled it by mistake must be able to stop it without hunting through settings.

Random audio, no character setting

The app has eight characters with eight warning lines each. It picks a random file on every unlock. There is no “warning character” preference.

That creates variety and avoids another settings concept. The tradeoff is that users cannot exclude a voice they dislike. I chose lower configuration cost for the first release and will measure feedback before adding filtering.

Known limitations

iOS is not supported.
The mode nudges; it does not enforce a block.
The foreground notification remains visible.
Vendor battery optimizations may affect behavior.
Without exact-alarm permission, automatic stopping may be delayed.
Preparing 64 local files has storage and setup cost.

Yominder combines spoken encouragement, authorized custom voice IDs, and this Android focus nudge.

https://yominder.app/?utm_source=devto&utm_medium=article&utm_campaign=dont_touch_architecture

Text Reminders Are Easy to Ignore: How I Built a Voice AI Sidekick App with Flutter

55tarkun — Thu, 06 Aug 2026 22:35:58 +0000

Have you ever set a reminder to take a break or hydrate, only to swipe away the notification without even reading it?

This is Notification Blindness — when our brains become so desensitized to banners, badges, and text popups that we automatically dismiss them.

As a remote worker and developer, I kept falling into this trap every day. To fix it for myself and others, I built Yominder, a Flutter-powered mobile app that replaces boring text notifications with lifelike voice AI personas that actually speak up.

💡 The Concept: Voice-First Routine Reminders

Instead of a generic chime and a text line, Yominder gives you distinct AI voice companions — from a supportive brother to a tsundere secretary or a fitness coach — that remind you throughout your remote work day:

🧘 Eye Strain / Posture: "Look away from the screen and gaze into the distance for 20 seconds."
⏱️ Pomodoro Technique: "Start Pomodoro. Focus for 25 minutes."
💧 Hydration: "Time to rehydrate!"
🏋️ Workout & Stretch: "It's time to workout! Muscle!"

🛠️ How It's Built with Flutter

Building a voice-first reminder app brought a few interesting engineering challenges:

Low Power Consumption: Running background audio tasks can easily drain phone battery if done wrong. I integrated lean OS background scheduling APIs (AlarmManager / Local Notifications) to trigger audio playback without keeping a heavy background process alive.
Cross-Platform Delivery: Built completely with Flutter to deliver identical high-quality UI and audio experiences on both iOS and Android from a single codebase.
Lifelike Voice Synthesis: Integrated AI voice generation to create distinct, natural-sounding voice personas rather than robotic text-to-speech.

🚀 Check It Out

Yominder is available for free on both iOS and Android:

🌐 Website: https://yominder.app/l10n/en/
📱 App Store: Download on iOS
🤖 Google Play: Get it on Android

I'd love to hear your thoughts! What tools or habits do you use to overcome notification fatigue while working remotely?

How I Built a Flat-Rate Reverse Geocoding API for Japan to Escape Google Maps Bill Shock

55tarkun — Sat, 01 Aug 2026 14:09:44 +0000

If you've ever built a global app or travel tool operating in Japan, you know the struggle:

Google Maps Geocoding API pricing: At $5.00 per 1,000 requests, unexpected traffic spikes can lead to terrifying monthly bills.
Messy Japanese address data: Official Japanese government (MLIT) CSVs and Japan Post files are difficult to normalize and query without self-hosting a spatial database like PostGIS.

To solve this for indie hackers and global dev teams, I built ReverseGeoJP — a fast, flat-rate reverse geocoding API for Japan address data.

What it does

Send a standard HTTP GET request with latitude and longitude:

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.reversegeojp.com/reverse?lat=35.6595&lon=139.6987"

Receive Japanese prefecture, city, town, postal code, and distance to town centroid in clean JSON:

{
  "prefecture": "東京都",           // Prefecture (e.g. Tokyo)
  "city": "渋谷区",               // City / Ward (e.g. Shibuya-ku)
  "town": "道玄坂二丁目",          // Town / District (e.g. Dogenzaka 2-chome)
  "zipcode": "1500043",            // 7-digit postal code
  "zipcode_candidates": ["1500043"],
  "distance_m": 36                  // Distance to town centroid (m)
}

How it's built

Cloudflare Workers & D1: Powered by SQLite at the edge, offering fast response times globally without server maintenance overhead.
Official Data: Sourced from official Ministry of Land, Infrastructure, Transport and Tourism (MLIT) location data and Japan Post records.
Flat-Rate Plans: Free tier (1,000 req/mo), then flat monthly subscriptions ($15/mo for 30k req, $39/mo for 200k req) with zero per-request surge charges.

Try it out

You can test the API and sign up for a free API key at https://api.reversegeojp.com/en (no credit card required).

I'd love to hear your feedback on the schema, performance, or features you'd like to see!