Quick Wins: Make Any Old Android Feel New Again (With Code)

Make any old Android feel new again — by writing four tiny apps

Hook: Your phone is sluggish, battery drains fast, storage constantly full, and the home screen stutters. Before you buy a new device, spend an afternoon building four tiny utilities that produce immediate, visible improvements — and teach you practical Android skills.

This tutorial converts the familiar 4-step cleanup routine into developer exercises. Each step becomes a small, focused app you can ship in a few hours: a storage scanner, a usage & battery inspector, an uninstall / replace helper, and a lightweight launcher that reduces perceived lag. These projects use modern, supported APIs (Jetpack, WorkManager, Storage Access Framework, UsageStats) and follow 2026 trends: Compose-first UIs, background work limits, and respectful privacy practices.

Quick roadmap — what you’ll build and why it matters

• Step 1: Storage Scanner — find big files and clear caches to free space and speed up I/O-bound apps.
• Step 2: Usage & Battery Inspector — identify heavy apps and schedule maintenance jobs with WorkManager.
• Step 3: Uninstall / Replace Helper — bulk-uninstall or replace bloated apps with lighter alternatives.
• Step 4: Minimal Launcher — create a low-overhead home screen to reduce redraws and animation costs.

All code examples are for beginners and use Kotlin + Jetpack. I’ll explain permissions, test steps, and quick ADB commands to measure improvements. You’ll come away with four small, reusable utilities and concrete performance wins.

The 2026 context — why these tiny apps still work

By 2026 Android’s power-management and privacy features have matured: OEM skins include smarter app standby buckets, and Android’s background limits are strict. That makes system-level sweeping tricks less reliable — but it also makes targeted, user-driven utilities more effective. A focused app that helps a user reclaim storage, identify misbehaving apps, or replace a heavy launcher can have a larger, safer impact than blanket “cleaner” apps of the past.

Trends to note:

• Compose-first UIs: Jetpack Compose is the default for fast, maintainable interfaces.
• WorkManager and foreground work: For reliable periodic maintenance tasks without draining battery.
• Scoped storage and SAF: Apps ask the user for explicit directories to inspect and modify, improving safety.
• Usage stats & app-standby APIs: Help you identify truly heavy apps (requires usage access permission).

Step 1 — Tiny Storage Scanner (free up space fast)

The problem: caches, downloads, and forgotten media files gradually fill flash storage. Low free space causes slowdowns (long app installs, slower I/O). The fix: a lightweight Storage Scanner that lists large files and lets the user remove them or open the system cleanup UI.

What the app does

• Scan a user-chosen directory using the Storage Access Framework (SAF).
• Present files sorted by size and age.
• Offer quick-delete actions or an option to open the file in the default viewer.

Why SAF?

Scoped storage prevents direct file-system access. SAF (ACTION_OPEN_DOCUMENT_TREE) gives controlled access to directories so your app can list and delete only what the user allows.

Minimal code snippet (Kotlin) — request a directory and list large files

// in an Activity or Compose LaunchedEffect
val pickDir = registerForActivityResult(ActivityResultContracts.OpenDocumentTree()) { uri ->
    uri?.let { 
        contentResolver.takePersistableUriPermission(
          it, Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION)
        // Now scan using DocumentFile
        val tree = DocumentFile.fromTreeUri(this, it)
        val files = tree?.listFiles()?.mapNotNull { f ->
            if (f.isFile) Pair(f.uri, f.length()) else null
        }?.sortedByDescending { it.second } ?: emptyList()
        // show files in UI
    }
}
// Launch: pickDir.launch(null)

Notes: DocumentFile.length() may return -1 for some providers; for media you can also query MediaStore for accurate sizes. Keep the UI responsive: scan on a background dispatcher.

UX tips

• Show largest items first and add an “older than X months” filter.
• Provide a “preview” and a one-tap delete with confirmation.
• Offer to open the system Storage settings when direct deletion is blocked.

Step 2 — Usage & Battery Inspector (find the real culprits)

Many phones drain battery because a small number of apps hold wakelocks, run constantly in the background, or perform frequent network operations. Identifying them is the key to targeted action.

What this utility does

• Checks whether the app has Usage Access (PACKAGE_USAGE_STATS) and prompts the user to grant it.
• Uses UsageStatsManager to show which apps consumed the most foreground & background time over the last 24–72 hours.
• Shows battery-related hints (open App battery settings, restrict background, or uninstall).

UsageStats quick example (Kotlin)

fun queryUsage(context: Context) {
  val usm = context.getSystemService(Context.USAGE_STATS_SERVICE) as UsageStatsManager
  val now = System.currentTimeMillis()
  val stats = usm.queryAndAggregateUsageStats(now - TimeUnit.DAYS.toMillis(1), now)
  // stats is a map of packageName -> UsageStats
}

fun ensureUsageAccess(context: Context) {
  val pm = context.packageManager
  val intent = Intent(Settings.ACTION_USAGE_ACCESS_SETTINGS)
  // Show explain dialog then startActivity(intent)
}

From the aggregated usage stats you can compute which apps had unusually high background time or frequent launches. Combine that with network or battery heuristics and the app can suggest actions.

Automated maintenance with WorkManager

Schedule a periodic WorkManager job to run diagnostic checks and remind the user if an app stays in a high-usage state for several days. WorkManager respects Doze and battery limits and is the recommended approach in modern Android.

class CheckHeavyAppsWorker(appContext: Context, params: WorkerParameters)
  : CoroutineWorker(appContext, params) {
    override suspend fun doWork(): Result {
      // run usage checks, notify user if anything suspicious
      return Result.success()
    }
}

val request = PeriodicWorkRequestBuilder(1, TimeUnit.DAYS)
  .build()
WorkManager.getInstance(context).enqueueUniquePeriodicWork("heavy-check", ExistingPeriodicWorkPolicy.KEEP, request)

Actionable takeaways for users

• Restrict background activity for apps flagged by the utility.
• Consider uninstalling or replacing apps that use excessive background CPU or network.
• Use the WorkManager reminders to nudge the user rather than performing intrusive changes automatically.

Step 3 — Uninstall and Replace Helper

This tiny app lists installed apps by size and shows “Uninstall” and “Replace” actions. For replacement, keep a curated mapping of heavy app → lightweight alternative (e.g., large social app → web PWA or a privacy-first client).

Why this is effective

Removing one big app can free hundreds of MB and stop background services. Replacing with a PWA or a lean client reduces background churn and battery use.

Uninstall and open Play Store (Kotlin)

fun uninstallPackage(context: Context, pkg: String) {
  val intent = Intent(Intent.ACTION_UNINSTALL_PACKAGE).apply {
    data = Uri.parse("package:$pkg")
    putExtra(Intent.EXTRA_RETURN_RESULT, true)
  }
  context.startActivity(intent)
}

fun openInPlayStore(context: Context, pkg: String) {
  try {
    context.startActivity(Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id=$pkg")))
  } catch (e: ActivityNotFoundException) {
    context.startActivity(Intent(Intent.ACTION_VIEW, Uri.parse("https://play.google.com/store/apps/details?id=$pkg")))
  }
}

UX and ethics

• Always confirm before uninstalling.
• Provide alternative options (web shortcuts, PWA installation prompts).
• Explain the tradeoffs: some replacements may lack features but improve battery and responsiveness.

Step 4 — Minimal Launcher: reduce perceived lag

Often perceived slowness comes from an overloaded launcher with widgets, live wallpapers, and heavy animations. A minimal launcher can drastically improve responsiveness. Build a basic Compose-based launcher that lists apps, supports search, and avoids heavy animations.

Launcher basics

• Declare the activity as a home launcher in the manifest (intent filter for ACTION_MAIN + CATEGORY_HOME).
• Keep composables light — prefer static lists and simple transitions.
• Disable continuous background updates or live widgets.

Compose snippet: simple app grid

@Composable
fun AppGrid(apps: List, onLaunch: (String) -> Unit) {
  LazyVerticalGrid(columns = GridCells.Fixed(4)) {
    items(apps) { app ->
      Column(modifier = Modifier.clickable { onLaunch(app.packageName) }) {
        Image(bitmap = app.iconBitmap, contentDescription = app.label)
        Text(app.label, maxLines = 1)
      }
    }
  }
}

Launching is a simple intent: startActivity(packageManager.getLaunchIntentForPackage(pkg)). The result: a home that consumes less RAM and CPU than many OEM launchers.

Bonus quick wins (developer & power-user tips)

• Use ADB to reduce animation scale (safe, reversible):

  adb shell settings put global window_animation_scale 0.5
  adb shell settings put global transition_animation_scale 0.5
  adb shell settings put global animator_duration_scale 0.5
  

  This shows immediate perceived speedups. Remind users to reset if they want normal animations later.
• Encourage enabling Adaptive Battery / battery saver — many OEMs added smarter heuristics between 2024–2026.
• Use built-in storage manager (Settings > Storage) for system-level cleanup when your app hits SAF limits.

Testing impact — measure before and after

To show visible improvements, measure a few simple metrics before and after:

• Free storage (Settings or stat with StatFs).
• Boot time (time from power-on to homescreen using a stopwatch — users notice this).
• App cold-start and warm-start times (Android Studio profiler or Timing logs).
• Battery drain rate over 6–24 hours (compare battery history graphs).

Example: freeing 2–5 GB often reduces background GC pressure and file I/O contention, improving app startup time by noticeable amounts on devices with limited RAM.

Privacy, permissions and safety

These utilities are designed to be transparent and user-driven:

• Use SAF for file access — never attempt to read other apps’ private data.
• Request PACKAGE_USAGE_STATS only to show usage; guide the user to the settings page for consent.
• Don’t clear other apps’ caches — you can prompt the user to take system actions instead.

Small, respectful tools that ask for explicit permissions build trust and survive OS changes better than one-shot “optimizers.”

Advanced strategies and 2026 predictions

As Android evolves, so will the ways to keep old phones feeling snappy. Two trends to watch and adopt:

• App standby bucketing and user automation: More devices let users move apps into stricter standby buckets; your utilities can suggest bucket changes and, with clear UI, help users automate them.
• Modular micro-tools and PWAs: Instead of monolithic system cleaners, modular micro-apps that each solve one problem will be more effective and more likely to pass Play Store review.

Prediction: by late 2026 we'll see a wave of single-purpose maintenance apps following the patterns above — Compose UIs, narrow permissions, and WorkManager reminders. If you build them now you’re ahead of the curve.

Common gotchas and how to handle them

• DocumentFile returns unknown sizes: For media files prefer MediaStore queries; for generic providers show age and name so users can make decisions.
• Users deny usage access: Provide clear explanation UI, show screenshots of where to enable it, and degrade gracefully.
• OEM customizations: Some skins aggressively kill background tasks or hide battery screens; your app should open the appropriate system settings page rather than trying to change system-wide policies programmatically.

Step-by-step afternoon plan (what to build in ~4 hours)

1. Hour 1 — Storage Scanner: scaffold Compose UI and implement ACTION_OPEN_DOCUMENT_TREE flow.
2. Hour 2 — Usage Inspector: request usage access and show aggregated usage stats for last 24 hours.
3. Hour 3 — Uninstall helper: list large apps and implement uninstall + Play Store link.
4. Hour 4 — Minimal Launcher shell: basic grid of apps, launch intents, and optional “set as home” flow.

Each step is incremental. Finish one and you already have a useful tool.

Real-world example: a student case study

One of my students built the Storage Scanner and Usage Inspector in an afternoon. After removing three forgotten APKs and a 1.2 GB download folder, their 3-year-old phone reported 3.4 GB free (previously < 400 MB). App cold-starts improved visibly and their daily battery drain dropped by around 8% measured over two days. Small, focused changes mattered more than a generic “optimizer.”

Resources & starter checklist

• Jetpack Compose documentation and templates.
• WorkManager guide for periodic work.
• Storage Access Framework & DocumentFile examples.
• UsageStatsManager reference and usage access flow.
• ADB animation commands for testing (developer-only).

Next steps — build, test, iterate

Pick one of the four projects and implement it. Measure the phone’s behavior before and after. Share results with a friend and iterate — add filters, smarter heuristics, or UI polish. These small projects produce real, visible improvement for old phones and teach you core Android skills used in production apps.

Call to action

Ready to get your hands dirty? Choose one step, clone a starter template (Compose + WorkManager), and build the first utility tonight. Post your before/after numbers, snippets, or questions on the community forum — I’ll review your code and suggest improvements. Let’s make old Androids feel new again, one small app at a time.

Related Reading

• Print Marketing on a Shoestring: Low-Cost VistaPrint Projects That Drive Sales
• Designing Multi-Channel Notifications for Signed Documents That Don't Break During Outages
• From Pot on a Stove to Global Brand: What Indie Cocktail Makers Teach Emerging Eyewear Labels
• Risk Matrix: When Social Platform Feature Updates Create New Legal Exposure
• Cheap Edge AI: Use Cases for Pi 5 + AI HAT in Remote Workflows