OptiDroid

Supercharge your Android device performance — one tap at a time.

Features • Screenshots • How It Works • Getting Started • Architecture • Tech Stack • Building • Contributing • License

✨ What is OptiDroid?

OptiDroid is a modern Android app that optimizes the ART (Android Runtime) compilation of every installed app on your device. It leverages dex2oat — Android's ahead-of-time compiler — to re-compile apps with aggressive optimization profiles, resulting in faster app launches, smoother scrolling, and better overall performance.

Think of it as defragmenting your phone's app layer — apps run native-speed code instead of interpreted bytecode.

🚀 Features

🔍 Smart Analysis

• Pre-scan all installed apps to determine which need optimization
• Intelligent skip logic — already-optimized and recently compiled apps are skipped
• Detailed per-app compilation status including compiler filter, timestamps, and OAT file presence

⚡ One-Tap Optimization

• Batch optimization of all apps that need it
• Real-time progress tracking with per-app status
• Live activity feed showing optimization logs as they happen
• Background execution via WorkManager with foreground notification

🎛️ Configurable Optimization Modes

🔐 Privileged Access via Shizuku

• No root required — uses Shizuku for privileged shell access
• Guided setup wizard walks you through enabling Shizuku step by step
• Automatic permission handling with clear status indicators

🎨 Beautiful Material 3 UI

• Material Design 3 Expressive with dynamic color theming
• Smooth 60fps animations on all state transitions
• Dark mode support out of the box
• Localization ready (English & Italian)

📱 Screenshots

Coming soon — PRs welcome!

🧠 How It Works

┌─────────────────────────────────────────────────────────┐
│  1. Setup    │  Enable Shizuku for privileged access     │
├──────────────┼───────────────────────────────────────────┤
│  2. Analyze  │  Scan all apps → find what needs work     │
├──────────────┼───────────────────────────────────────────┤
│  3. Optimize │  Run `cmd package compile` on each app    │
├──────────────┼───────────────────────────────────────────┤
│  4. Enjoy    │  Faster launches & smoother performance   │
└─────────────────────────────────────────────────────────┘

Under the hood, OptiDroid:

1. Connects to a privileged shell via Shizuku (or wireless ADB)
2. Analyzes every installed package's compilation status using dumpsys package and OAT file metadata
3. Filters out apps that are already optimized, system apps, or recently compiled
4. Executes cmd package compile -m <mode> -f <package> for each app that needs optimization
5. Streams real-time progress and logs back to the UI via StateFlow

🏁 Getting Started

Prerequisites

Quick Start

1. Install Shizuku and start the Shizuku service
2. Install OptiDroid (build from source or grab a release)
3. Grant permission — OptiDroid will guide you through the Shizuku setup
4. Tap Analyze to scan your apps
5. Tap Optimize and watch the magic happen ✨

🏗️ Architecture

OptiDroid follows Clean Architecture with MVVM + Unidirectional Data Flow (UDF).

┌──────────────────────────────────────────────────────────┐
│                    Presentation Layer                      │
│  ┌──────────────┐  ┌───────────┐  ┌───────────────────┐  │
│  │  Composables  │←─│ ViewModels│←─│ UiModels/UiState  │  │
│  │  (Screens)    │──│ (State +  │  │ (Immutable)       │  │
│  │               │  │  Events)  │  │                   │  │
│  └──────────────┘  └─────┬─────┘  └───────────────────┘  │
│                          │                                 │
├──────────────────────────┼─────────────────────────────────┤
│                    Domain Layer (Pure Kotlin)               │
│  ┌──────────────┐  ┌─────┴─────┐  ┌───────────────────┐  │
│  │  Use Cases    │  │Repository │  │  Domain Models     │  │
│  │  (invoke())   │  │Interfaces │  │  (Entities)        │  │
│  └──────────────┘  └─────┬─────┘  └───────────────────┘  │
│                          │                                 │
├──────────────────────────┼─────────────────────────────────┤
│                    Data Layer                               │
│  ┌──────────────┐  ┌─────┴─────┐  ┌───────────────────┐  │
│  │  Repository   │  │   Data    │  │  Shizuku / ADB    │  │
│  │  Impls        │  │  Sources  │  │  Shell Clients    │  │
│  └──────────────┘  └───────────┘  └───────────────────┘  │
└──────────────────────────────────────────────────────────┘

Project Structure

com.tony.appbooster/
├── 📂 data/              # Repository implementations, shell clients
│   ├── client/           # ADB & Shizuku shell client implementations
│   ├── repository/       # Concrete repository classes
│   └── scheduler/        # WorkManager schedulers
├── 📂 domain/            # Pure Kotlin — zero Android dependencies
│   ├── client/           # Shell client interfaces
│   ├── model/            # Domain entities (Progress, Analysis, Config)
│   ├── repository/       # Repository contracts
│   ├── scheduler/        # Work scheduler interfaces
│   └── usecase/          # Business logic (Analyze, Optimize, Connect)
├── 📂 presentation/      # UI layer (Compose + ViewModels)
│   ├── navigation/       # Navigation graph & Screen definitions
│   ├── screen/           # Composable screens (Dashboard, Settings, Shizuku)
│   ├── ui/               # Theme, components, design system
│   ├── viewmodel/        # ViewModels + UiModels
│   └── worker/           # WorkManager workers for background optimization
└── 📂 di/                # Hilt dependency injection modules

🛠️ Tech Stack

🔨 Building

Prerequisites

• Android Studio Ladybug (2024.3+) or newer
• JDK 17+
• Android SDK 36

Build & Run

# Clone the repository
git clone https://github.com/yourusername/OptiDroid.git
cd OptiDroid

# Build debug APK
./gradlew assembleDebug

# Install on connected device
./gradlew installDebug

# Run unit tests
./gradlew runUnitTests

# Run all tests (requires connected device)
./gradlew runAllTests

Build Variants

GitHub Actions CI

The repository includes a GitHub Actions workflow at .github/workflows/android-ci.yml with three jobs:

The release tag is derived automatically from versionName and versionCode in app/build.gradle.kts (e.g. v1.0-1).

Changelog: When you merge a PR into master, the CI extracts the PR description and uses it as the release notes. If no matching PR is found (e.g. a direct push), it falls back to the last 10 commit messages.

Configure these repository secrets:

All four secrets are required for the release & publish jobs. Unit tests still run on every push and PR regardless of secrets.

🧪 Testing

OptiDroid uses a modern testing stack with clear naming conventions:

@Test
fun `given apps need optimization when optimize invoked then returns success`()

# Unit tests only (no device needed)
./gradlew runUnitTests

# Instrumented tests (requires device/emulator)
./gradlew runInstrumentedTests

# Full suite
./gradlew runAllTests

Reports are generated at:

• Unit tests → app/build/reports/tests/testDebugUnitTest/index.html
• Instrumented → app/build/reports/androidTests/connected/debug/index.html

🤝 Contributing

Contributions are welcome! Here's how to get started:

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

🤖 AI Coding Guidelines — Use Our Copilot Instructions

This project ships a .github/copilot-instructions.md file tracked in Git.

If you use GitHub Copilot, Cursor, JetBrains AI, or any AI-powered coding assistant, point it to this file. It contains the full architecture rules, documentation standards, Compose patterns, and forbidden practices that keep the codebase clean and consistent.

How to use it:

Following these instructions ensures every contribution matches the project's Clean Architecture, MVVM + UDF patterns, KDoc standards, and Material 3 Expressive UI conventions — whether the code is written by a human or generated by AI.

Guidelines

• Follow the AI coding guidelines for architecture, style, and documentation standards
• Write KDoc for all public APIs
• Include unit tests for new use cases and ViewModels
• Use Material 3 Expressive components with proper animations
• Keep the domain layer free of Android dependencies

📄 License

Copyright 2025 Tony

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

🙏 Acknowledgments

• Shizuku — Privileged API access without root
• Dadb — Pure Kotlin ADB client
• Jetpack Compose — Modern declarative UI
• Material Design 3 — Design system & components

Made with ❤️ and Kotlin

V1.7.0

• Improve layout of activity card
• Improved settings screen code