flutter-dependency-injection

$npx mdskill add HoangNguyen0403/agent-skills-standard/flutter-dependency-injection

```text core/injection/ ├── injection.dart # Initialization & setup └── modules/ # Third-party dependency modules (Dio, Storage) ```

SKILL.md

.github/skills/flutter-dependency-injectionView on GitHub ↗
---
name: flutter-dependency-injection
description: Configure service locator setup using injectable and get_it in Flutter. Use when wiring dependency injection with get_it or injectable.
metadata:
  triggers:
    files:
    - '**/injection.dart'
    - '**/locator.dart'
    keywords:
    - GetIt
    - injectable
    - singleton
    - module
    - lazySingleton
    - factory
---
# Dependency Injection

## **Priority: P1 (HIGH)**


## Structure

```text
core/injection/
├── injection.dart  # Initialization & setup
└── modules/        # Third-party dependency modules (Dio, Storage)
```

## Implementation Workflow

1. **Annotate classes** — Use `@injectable` annotations; avoid manual registry calls.
2. **Choose scope** — Default to `@LazySingleton` for repositories, services, and data sources (init on demand).
3. **Register BLoCs as factories** — Use `@injectable` (Factory) for BLoCs to ensure state resets per instance. Never use `@Singleton()` for BLoCs.
4. **Inject abstractions** — Always register implementations as abstract interfaces (`as: IService`).
5. **Register third-party deps** — Use `@module` for external instances (Dio, Hive, SharedPreferences).
6. **Prefer constructor injection** — Use mandatory constructor parameters; `injectable` resolves them automatically.

### Registration & Test Mock Examples

See [implementation examples](references/implementation.md) for module registration and test mock swap patterns.

## Reference & Examples

For module configuration and initialization templates:
See [references/REFERENCE.md](references/REFERENCE.md).

## Anti-Patterns

- **No Inline `getIt` Calls**: Inject via constructor instead of calling GetIt in UI `build()`
- **No `@Singleton` BLoCs**: Always use `@injectable` (Factory) to ensure state resets
- **No Concrete Class Injection**: Always inject abstract interface (e.g., `IOrderRepository`)
- **No Manual Registration**: Use `@injectable` annotations instead of manual `getIt.register` calls in production code

## Related Topics

layer-based-clean-architecture | testing

More from HoangNguyen0403/agent-skills-standard

SkillDescription
android-agp-upgradeUpgrade an Android project to Android Gradle Plugin (AGP) 9. Use when migrating to AGP 9, updating Gradle build files, migrating to built-in Kotlin, or adopting the new AGP DSL.
android-architectureApply Clean Architecture layering, modularization, and Unidirectional Data Flow in Android projects. Use when setting up project structure, placing code in layers, configuring feature/core modules, or implementing UDF patterns.
android-background-workImplement WorkManager and background processing correctly on Android. Use when creating Worker classes, scheduling tasks, choosing between WorkManager and Foreground Services, or setting up Hilt in workers.
android-composeBuild high-performance declarative UI with Jetpack Compose. Use when writing Composable functions, optimizing recomposition, hoisting state, or working with LazyColumn and side effects.
android-compose-migrationMigrate an Android XML View to Jetpack Compose following a structured 10-step workflow. Use when converting XML layouts to Compose, setting up Compose in an existing View-based project, or incrementally adopting Compose.
android-concurrencyWrite correct coroutine scopes, Flow collection, and dispatcher injection in Android. Use when writing suspend functions, choosing between StateFlow and SharedFlow, or injecting Dispatchers for testability.
android-deploymentConfigure release signing, R8 obfuscation, and App Bundle publishing for Android. Use when setting up signing configs, enabling minification, adding ProGuard keep rules, or preparing for Play Store submission.
android-design-systemEnforce Material Design 3 theming and design token usage in Jetpack Compose. Use when implementing M3 components, color schemes, typography, or design tokens.
android-diConfigure Hilt dependency injection with proper scoping, modules, and constructor injection in Android. Use when setting up Hilt DI, defining modules, or configuring component scoping.
android-edge-to-edgeMigrate a Jetpack Compose app to edge-to-edge display and fix system bar inset issues. Use when UI components are obscured by navigation/status bars, fixing IME insets, or enabling edge-to-edge for SDK 35+.