Flutter apps are known for their beautiful designs and smooth functionality, but performance issues can quickly ruin the user experience. Take your app to the next level with these 10 expert tips for optimizing performance.

Use the WidgetsBindingObserver to track the lifecycle of your app

Use the "WidgetsBindingObserver" to track the lifecycle of your app. This observer allows you to receive callbacks when the app is resumed, paused, or inactive, which can help you identify performance bottlenecks and optimize your app's behaviour.

class MyApp extends StatefulWidget {
  @override
  _MyAppState createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> with WidgetsBindingObserver {
  @override
  void initState() {
    WidgetsBinding.instance.addObserver(this);
    super.initState();
  }

  @override
  void dispose() {
    WidgetsBinding.instance.removeObserver(this);
    super.dispose();
  }

  @override
  void didChangeAppLifecycleState(AppLifecycleState state) {
    // Handle state changes here
  }

  //...
}

Use the RepaintBoundary widget to isolate parts of your app

Use the "RepaintBoundary" widget to isolate parts of your app that are causing performance issues. The "RepaintBoundary" widget can be used to wrap a widget that is causing performance issues so that the rest of the app can continue to run smoothly.

RepaintBoundary(
  child: MyExpensiveWidget(),
);

Use the InheritedWidget for data

Use the "InheritedWidget" for data that is passed down the widget tree. The "InheritedWidget" is a special kind of widget that can be used to pass data down the widget tree, which can help reduce the number of rebuilds and improve performance.

class MyInheritedWidget extends InheritedWidget {
  final int myData;

  MyInheritedWidget({
    Key key,
    @required this.myData,
    @required Widget child,
  }) : super(key: key, child: child);

  @override
  bool updateShouldNotify(MyInheritedWidget old) => myData != old.myData;

  static MyInheritedWidget of(BuildContext context) {
    return context.dependOnInheritedWidgetOfExactType<MyInheritedWidget>();
  }
}

Use the StreamBuilder instead of the FutureBuilder

Use the "StreamBuilder" instead of the "FutureBuilder" whenever possible. The "StreamBuilder" allows you to receive updates as they happen, which can help reduce the number of rebuilds and improve performance.

StreamBuilder(
  stream: myStream,
  builder: (BuildContext context, AsyncSnapshot snapshot) {
    if (snapshot.hasData) {
      return Text(snapshot.data);
    } else if (snapshot.hasError) {
      return Text(snapshot.error);
    }
    return CircularProgressIndicator();
  },
);

Use the CustomScrollView instead of the ListView

Use the "CustomScrollView" instead of the "ListView" whenever possible. The "CustomScrollView" is more efficient than the "ListView" because it only builds the widgets that are currently visible on the screen.

CustomScrollView(
  slivers: <Widget>[
    SliverList(
      delegate: SliverChildBuilderDelegate(
        (BuildContext context, int index) {
          return MyListItem(data: myData[index]);
        },
        childCount: myData.length,
      ),
    ),
  ],
);

Use the AnimationController to control animations

Use the "AnimationController" to control animations. The "AnimationController" allows you to control the timing and progression of animations, which can help reduce the number of rebuilds and improve performance.

class MyAnimationWidget extends StatefulWidget {
  @override
  _MyAnimationWidgetState createState() => _MyAnimationWidgetState();
}

class _MyAnimationWidgetState extends State<MyAnimationWidget>
    with SingleTickerProvider{
    AnimationController _controller;

    @override
    void initState() {
    _controller = AnimationController(vsync: this, duration: Duration(seconds: 2));
    super.initState();
    }

    @override
    void dispose() {
    _controller.dispose();
    super.dispose();
    }

    @override
    Widget build(BuildContext context) {
        return AnimatedBuilder(
        animation: _controller,
        builder: (context, child) {
        // Use _controller.value to control the animation
        return Transform.translate(
        offset: Offset(0, _controller.value * 100),
        child: child,
        );
        },
        child: MyChildWidget(),
        );
    }
}

Use the Wrap widget instead of the ListView widget

Use the "Wrap" widget instead of the "ListView" widget whenever possible. The "Wrap" widget is more efficient than the "ListView" because it only builds the widgets that are currently visible on the screen.

Wrap(
  children: myChildren.map((child) => MyChildWidget(child)).toList(),
);

Use the CustomPainter widget to draw complex graphics

Use the "CustomPainter" widget to draw complex graphics. The "CustomPainter" widget allows you to draw directly to the canvas, which can be much more efficient than building a large number of nested widgets.

class MyCustomPainter extends CustomPainter {
  @override
  void paint(Canvas canvas, Size size) {
    // Draw complex graphics on the canvas
  }

  @override
  bool shouldRepaint(CustomPainter oldDelegate) {
    return false;
  }
}

Use the PerformanceOverlay widget to see a live visualization of your app's performance.

Use the "PerformanceOverlay" widget to see a live visualization of your app's performance. This widget can help you identify areas of your app that may be causing performance issues and give you ideas for how to optimize them.

PerformanceOverlay(
  enabled: true,
  overlayRect: Rect.fromLTWH(0, 0, 200, 200),
  children: [
    // Your widgets
  ],
);

Use Dart's built-in Profile and Release modes for testing performance

Use Dart's built-in "Profile" and "Release" modes for testing performance. Profile mode gives you detailed performance information, Release mode optimizes the app for performance and speed, this will help you to identify and fix performance issues.

flutter run --profile

or

flutter run --release

Please note that these are just examples of what the code might look like, and are not meant to be copy-pasting solutions. The actual implementation may vary depending on the specific needs of your app.

If you've come so far, thanks a lot for reading. I share insightful content on flutter at least once a week on hashnode.

Follow me for more such content.

Ciao👋