Auto Dispose Mixin #

Zero-Boilerplate Lifecycle Management for Flutter Widgets

auto_dispose_mixin automatically disposes controllers, subscriptions, notifiers, and custom resources when a StatefulWidget is removed from the widget tree — without overriding dispose().

Designed for performance, safety, and developer ergonomics.

🚀 Why This Package Exists #

Memory leaks are one of the most common performance issues in Flutter apps.

Typical problems:

• Forgetting to dispose TextEditingController
• Leaking StreamSubscription
• Missing AnimationController.dispose()
• Bloated dispose() methods
• Inconsistent cleanup across teams

❌ Traditional Approach #

@override
void dispose() {
  controller.dispose();
  scrollController.dispose();
  animationController.dispose();
  subscription.cancel();
  super.dispose();
}

✅ With AutoDisposeMixin #

class _MyWidgetState extends State<MyWidget>
    with AutoDisposeMixin {

  late final controller =
      registerForDispose(TextEditingController());

  // No dispose() override needed 🎉
}

✨ Features #

• ✅ Automatic disposal of common Flutter resources
• ✅ Works with AnimationController (ticker-safe)
• ✅ Stream subscription cleanup
• ✅ Custom disposable objects
• ✅ Duck typing (dispose() detection)
• ✅ Manual cleanup callbacks
• ✅ DevTools logging
• ✅ Performance timing
• ✅ Zero runtime overhead in release mode
• ✅ No code generation
• ✅ No reflection
• ✅ No magic

📦 Installation #

Add to pubspec.yaml:

dependencies:
  auto_dispose_mixin: ^1.*.*

Then run:

flutter pub get

🧩 Basic Usage #

Step 1: Add the mixin #

class _MyPageState extends State<MyPage>
    with AutoDisposeMixin {

Step 2: Register disposables #

late final TextEditingController controller =
    registerForDispose(TextEditingController());

late final ScrollController scrollController =
    registerForDispose(ScrollController());

That’s it.

No dispose() override required.

🎯 Supported Disposable Types #

AutoDisposeMixin automatically handles an exhaustive list of Flutter and Dart controllers, natively saving you from writing disposal boilerplate.

ChangeNotifier / ValueNotifier Family #

(Most UI Controllers)

• TextEditingController
• ScrollController, PageController, TabController
• AnimationController
• FocusNode, FocusScopeNode
• SearchController
• Any custom class extending ChangeNotifier or ValueNotifier

Streams & Sinks #

(Async Data)

• StreamSubscription → .cancel()
• StreamController, BroadcastStreamController → .close()
• IOSink, EventSink, WebSocket → .close()

UI & Flutter Core #

• OverlayEntry → Natively calls .remove() if mounted, then .dispose()
• Timer / RestartableTimer → .cancel()
• Ticker → .stop(), .dispose()

Custom Disposable Interface #

abstract class Disposable {
  bool get isDisposed;
  void dispose();
  void markDisposed();
}

Advanced Duck Typing (The "Senior Dev" Checklist) #

If your object isn't in the standard Flutter list above, AutoDisposeMixin will dynamically detect and safely call its cleanup method. This automatically handles thousands of 3rd party plugins (like VideoPlayerController, GetX Worker, etc).

The mixin implicitly supports anything that has:

• .dispose() (e.g. TapGestureRecognizer, Plugin controllers)
• .cancel() (e.g. Worker, EventChannel subscriptions)
• .close() (e.g. ReceivePort, PersistentBottomSheetController)
• .kill() (e.g. Isolate)

class FakeSocketClient {
  void close() {
    print('Socket closed');
  }
}

late final socket =
    registerForDispose(FakeSocketClient());

Manual Cleanup #

registerDisposeCallback(() {
  // custom cleanup
});

🎞 AnimationController & Ticker Support #

✅ Correct Mixin Order (IMPORTANT) #

When using tickers:

class _MyWidgetState extends State<MyWidget>
    with SingleTickerProviderStateMixin, AutoDisposeMixin {

Rule: AutoDisposeMixin must be the last mixin.

Why? #

• Flutter requires ticker providers to be initialized first
• AutoDisposeMixin depends on fully constructed controllers

🧠 Example: AnimationController #

late final AnimationController animationController =
    registerForDispose(
      AnimationController(
        vsync: this,
        duration: const Duration(seconds: 1),
      ),
    );

The package will:

• Stop animation if running
• Dispose safely
• Track performance (optional)

🔌 StreamSubscription Example #

late final StreamSubscription<int> subscription =
    registerForDispose(
      Stream.periodic(const Duration(seconds: 1))
          .listen(print),
    );

Automatically calls .cancel() on dispose.

🧪 Custom Disposable Example #

class FakeSocketClient {
  void dispose() {
    print('Socket closed');
  }
}

late final socket =
    registerForDispose(FakeSocketClient());

Duck typing detects .dispose() automatically.

🧹 Manual Dispose Callback #

For edge cases:

registerDisposeCallback(() {
  debugPrint('Manual cleanup');
});

Executed after all registered disposables.

🛠 Debug & DevTools Integration #

Enable Debug Reporting #

void main() {
  AutoDisposeDebug.debugReportEnabled = true;
  AutoDisposeDebug.trackPerformance = true;
  runApp(MyApp());
}

What You Get #

• ✔ Per-object dispose logs
• ✔ Non-disposable warnings
• ✔ Total dispose time
• ✔ DevTools timeline visibility

Example output:

Dispose Summary for _MyPageState
---------------------------------
Disposed: 6
Not Disposable: 1
Total Time: 312µs

📊 Performance Tracking #

When enabled:

• Each disposable tracks execution time
• Total dispose duration is logged
• Uses Stopwatch internally
• Disabled in release mode by default

⚠️ Best Practices #

✅ DO #

• Use late final with registerForDispose
• Keep AutoDisposeMixin last
• Enable debug mode during development

❌ DON’T #

• Manually call .dispose() on registered objects
• Register objects after dispose() is called
• Use with non-State classes

🧪 Example App #

To generate an example project:

flutter create example

Then import your package:

import 'package:auto_dispose_mixin/auto_dispose_mixin.dart';

A full example is included in /example.

🧩 Architecture Philosophy #

• No code generation
• No build_runner
• No reflection
• No runtime cost
• Flutter-native lifecycle
• Predictable behavior

This package augments Flutter — it does not fight it.

🛣 Roadmap #

Planned features:

• Leak detection warnings
• DevTools UI extension
• Dispose order visualization
• Zone-based lifecycle scopes

❤️ Contributing #

Contributions welcome.

• Add new disposable resolvers
• Improve DevTools logging
• Write tests
• Improve documentation

📄 License #

MIT License
https://github.com/ASHISH1317/auto_dispose_mixin/blob/main/LICENSE

⭐ Final Note #

If you’ve ever forgotten to dispose something in Flutter this package is for you.

Simple. Safe. Fast.