Android Debug Drawer

A comprehensive, production-ready debug drawer for Android apps that provides developers with powerful debugging tools directly within their applications.

Stop switching between your app and external debugging tools. This library gives you everything you need for debugging right inside your app - real-time logcat streaming, network request monitoring, feature flag toggles, app inspection, and more. Perfect for QA testing, development debugging, and production troubleshooting.

Built by developers, for developers. Created by Malik Abualzait with a focus on simplicity, performance, and extensibility.

🎯 Why Android Debug Drawer?

• 🚀 Zero Setup - Get started in minutes with minimal configuration
• 🔧 Modular Design - Add or remove debugging modules as needed
• 📱 Production Ready - Automatically disabled in release builds
• 🎨 Beautiful UI - Clean, intuitive interface following Material Design principles
• ⚡ High Performance - Lightweight with minimal impact on app performance
• 🧪 Well Tested - Comprehensive test coverage with CI/CD pipeline

⚡ Quick Start

Want to try it right now? Download the latest APK and install it on your device:

1. Click the button above → Go to latest workflow run → Download APK artifact
2. Install on your Android device
3. Open the app and tap "Toggle Debug Drawer"
4. Explore all the debugging modules!

🌟 Features

🔧 Modular Architecture

Pick and choose only the debugging tools you need. Each module is independent and can be added/removed dynamically.

📱 Built-in Debug Modules

• 📱 App & Device Info - View app version, device model, Android version, and build details
• 🌐 Network Monitoring - Real-time HTTP request/response logging with headers, timing, and status codes
• 📋 Advanced Logcat Viewer - Stream system and app logs with real-time filtering, search, and export
• 🚩 Feature Flags - Toggle features at runtime with persistent storage across app restarts
• ⚙️ Settings Override - Modify app settings on-the-fly for testing different configurations
• 📋 Clipboard Tools - Copy/paste utilities for testing text input scenarios

🚀 Developer Experience

• Zero Performance Impact - Automatically disabled in release builds
• Real-time Updates - Live log streaming and network monitoring
• Easy Integration - Works with existing Hilt/DI setup
• Extensible - Create custom modules for your specific needs

🛠️ Tech Stack

• Language: Kotlin
• UI: Traditional Android Views (XML + Kotlin)
• Dependency Injection: Hilt
• Networking: Retrofit + OkHttp (for request logging)
• Persistence: DataStore (feature flags & settings)
• Testing: JUnit, Mockito, Robolectric, Espresso
• Code Quality: ktlint, detekt

📐 Architecture

• Library Module (debugdrawer) → reusable across projects
• Sample App Module (sampleapp) → demonstrates usage
• Modular Design: Each widget = independent module that can be added dynamically to the drawer

📖 User Manual

Getting Started

The Android Debug Drawer is designed to be simple to integrate and use. Follow these steps to get started:

1. Installation

🚀 JitPack (Recommended)

Add to your project's build.gradle.kts (project level):

allprojects {
    repositories {
        google()
        mavenCentral()
        maven { url = uri("https://jitpack.io") }
    }
}

Add to your app's build.gradle.kts:

dependencies {
    debugImplementation("com.github.mabualzait:Android-Debug-Drawer:1.2.5")
}

Available versions:

• 1.2.5 - Latest stable release ✅ (JitPack auto-detection working)
• main-SNAPSHOT - Latest development version

🔧 Local Development (Clone as Module)

For contributing or custom modifications:

1. Clone and integrate:

   git clone https://github.com/mabualzait/Android-Debug-Drawer.git
   # Copy debugdrawer folder to your project root

2. Add to settings.gradle.kts:

   include(":debugdrawer")

3. Add dependency:

   dependencies {
       debugImplementation project(":debugdrawer")
   }

2. Setup

🚀 Super Simple Integration (Recommended)

Step 1: Add Hilt to your project (if not already added):

plugins {
    id("com.google.dagger.hilt.android")
    id("kotlin-kapt")
}

dependencies {
    implementation("com.google.dagger:hilt-android:2.48")
    kapt("com.google.dagger:hilt-compiler:2.48")
}

Step 2: Update your Application class:

@HiltAndroidApp
class MyApplication : com.abualzait.debugdrawer.DebugDrawerApplication() {
    // That's it! No additional code needed!
}

Step 3: Your MainActivity requires ZERO debug drawer code:

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // No debug drawer setup needed!
    }
}

🎉 Done! The debug drawer is now automatically available with:

• Gesture activation: Long press or double tap anywhere on screen
• All modules included: App info, network monitoring, logcat, feature flags, settings, clipboard
• Auto-initialization: Works across all activities
• Zero boilerplate: No manual setup required

✨ What Changed - Developer Experience Revolution

Before (Old Way)	After (New Way)
❌ 6+ @Inject declarations	✅ 0 declarations needed
❌ Manual initialization	✅ Automatic initialization
❌ Manual module registration	✅ Auto-registered modules
❌ Manual cleanup in onDestroy	✅ Automatic cleanup
❌ 20+ lines of setup code	✅ 1 line: extend DebugDrawerApplication
❌ Button required for activation	✅ Gesture-based activation
❌ Complex integration	✅ True plug-and-play

🔧 Advanced Integration (Optional)

If you need custom control, you can still use the traditional approach:

@HiltAndroidApp
class MyApplication : Application() {
    @Inject
    lateinit var debugDrawerInitializer: com.abualzait.debugdrawer.DebugDrawerInitializer

    override fun onCreate() {
        super.onCreate()
        debugDrawerInitializer.initializeIfEnabled(this)
    }
}

🎮 Manual Control (When Needed)

// Show/hide programmatically
com.abualzait.debugdrawer.DebugDrawerUtils.toggle(context)
com.abualzait.debugdrawer.DebugDrawerUtils.show(context)
com.abualzait.debugdrawer.DebugDrawerUtils.hide(context)

// Check visibility
val isVisible = com.abualzait.debugdrawer.DebugDrawerUtils.isVisible(context)

3. Usage

🎮 Activation Methods

Automatic Gestures (Zero Code Required):

• Long press anywhere on the screen
• Double tap anywhere on the screen

Programmatic Control (When Needed):

// Show/hide programmatically
com.abualzait.debugdrawer.DebugDrawerUtils.toggle(context)
com.abualzait.debugdrawer.DebugDrawerUtils.show(context)
com.abualzait.debugdrawer.DebugDrawerUtils.hide(context)

// Check visibility
val isVisible = com.abualzait.debugdrawer.DebugDrawerUtils.isVisible(context)

UI Button (Optional):

findViewById<Button>(R.id.btn_toggle_debug)?.setOnClickListener {
    com.abualzait.debugdrawer.DebugDrawerUtils.toggle(this)
}

Module Overview

Module	Purpose	Key Features
📱 App Info	App & device inspection	Version, package, device model, Android version
🌐 Network	HTTP monitoring	Request/response logging, timing, status codes
📋 Logcat	Real-time log streaming	Live filtering, search, export, auto-scroll
🚩 Feature Flags	Runtime feature toggles	Persistent storage, A/B testing support
⚙️ Settings	Configuration override	Runtime settings modification
📋 Clipboard	Text utilities	Copy/paste for testing scenarios

Real-world Use Cases

🔍 Development Debugging:

• Monitor network requests during API development
• Stream logs in real-time without switching to external tools
• Toggle features instantly for testing different flows

🧪 QA Testing:

• Inspect app version and device info for bug reports
• Test feature combinations with flag toggles
• Override settings to test edge cases

🐛 Production Troubleshooting:

• Enable debug drawer in debug builds for customer support
• Export logs for analysis
• Monitor network issues in real-time

4. Advanced Usage

Module Management

// Add/remove modules dynamically
debugDrawer.addModule(customModule)
debugDrawer.removeModule(logsModule)

// Check drawer state
if (debugDrawer.isVisible()) {
    // Handle visibility
}

Network Monitoring Setup

@Module
@InstallIn(SingletonComponent::class)
object NetworkModule {
    @Provides
    @Singleton
    fun provideOkHttpClient(networkInterceptor: NetworkInterceptor): OkHttpClient {
        return OkHttpClient.Builder()
            .addInterceptor(networkInterceptor)
            .build()
    }
}

Feature Flags Integration

@Inject
lateinit var featureFlagsModule: com.abualzait.debugdrawer.modules.FeatureFlagsModule

// Check feature state
lifecycleScope.launch {
    val isEnabled = featureFlagsModule.isFeatureEnabled("new_feature")
    if (isEnabled) {
        // Enable new feature
    }
}

Custom Modules

class CustomModule @Inject constructor(
    private val context: Context
) : DebugModule {
    
    override val name = "custom"
    override val title = "Custom Module"
    override val description = "My custom debugging tool"
    
    override fun createView(): View {
        return LayoutInflater.from(context)
            .inflate(R.layout.custom_module_layout, null)
    }
}

📁 Project Structure

android-debug-drawer/
├── debugdrawer/                    # Library module
│   ├── src/main/java/com/debugdrawer/
│   │   ├── DebugDrawer.kt         # Main debug drawer class
│   │   ├── modules/               # Debug modules
│   │   │   ├── AppInfoModule.kt
│   │   │   ├── NetworkModule.kt
│   │   │   ├── com.abualzait.debugdrawer.modules.FeatureFlagsModule.kt
│   │   │   ├── LogsModule.kt
│   │   │   ├── com.abualzait.debugdrawer.modules.SettingsModule.kt
│   │   │   └── ClipboardModule.kt
│   │   ├── utils/                 # Utility classes
│   │   │   ├── Logger.kt
│   │   │   └── NetworkInterceptor.kt
│   │   └── di/                    # Dependency injection
│   │       └── DebugDrawerModule.kt
│   └── src/main/res/layout/       # Layout files
│       ├── module_app_info.xml
│       ├── module_network.xml
│       └── ...
├── sampleapp/                     # Sample application
│   ├── src/main/java/com/debugdrawer/sampleapp/
│   │   ├── MainActivity.kt
│   │   ├── SampleApplication.kt
│   │   └── network/
│   │       └── SampleNetworkClient.kt
│   └── src/main/res/
├── .github/workflows/             # CI/CD workflows
│   └── ci.yml
├── README.md
├── build.gradle.kts
└── settings.gradle.kts

🧪 Testing

The project includes comprehensive testing:

Unit Tests

./gradlew test

Instrumented Tests

./gradlew connectedAndroidTest

Code Coverage

./gradlew jacocoTestReport

Code Quality

./gradlew ktlintCheck
./gradlew detekt

📊 Code Quality

This project maintains high code quality standards:

• ktlint for code formatting
• detekt for static analysis
• Unit tests with JUnit, Mockito, and Robolectric
• Integration tests with Espresso
• Code coverage reporting with JaCoCo

🚀 CI/CD

The project uses GitHub Actions for continuous integration:

• Code Quality Checks - ktlint, detekt
• Unit Tests - JUnit, Mockito, Robolectric
• Instrumented Tests - Espresso on Android emulator
• Build Verification - Debug and release APK builds
• Code Coverage - JaCoCo reports uploaded to Codecov

📝 License

This project is licensed under the MIT License - see the LICENSE file for details.

🤝 Contributing

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

📞 Support

If you have any questions or need help, please:

1. Check the Issues page
2. Create a new issue if your question isn't already answered
3. Join our discussions for general questions

🎬 Demo

Check out the sample app included in this repository to see the Android Debug Drawer in action:

1. Clone the repository
2. Open in Android Studio
3. Run the sampleapp module
4. Tap "Toggle Debug Drawer" to see all features

📸 Screenshots

Main Interface

Main debug drawer interface with module selection grid

Logcat Viewer

Enhanced logcat viewer with real-time streaming and filtering

Network Monitoring

Network request monitoring and logging

App Information

App and device information display

🚀 Roadmap

• JitPack integration for easy dependency management
• More built-in modules (Database Inspector, Performance Monitor)
• Custom theme support
• Gesture-based activation (shake to open)
• Export functionality for logs and settings
• Plugin system for third-party modules

🙏 Acknowledgments

• Material Design for the UI components
• Hilt for dependency injection
• Retrofit for networking
• DataStore for data persistence
• Special thanks to the Android development community for inspiration and feedback

Developer: Malik Abualzait - Android Developer & Open Source Contributor

---

Made with ❤️ by Malik Abualzait for the Android development community