RtDependencyLifecycle

Tip

This documentation assumes you’ve already read the Lifecycle. It’s recommended read that first if you’re new in Reactter.

RtDependencyLifecycle is a class that provides a way to observe the lifecycle of a dependency.

Syntax

abstract class RtDependencyLifecycle {
  void onCreated() {}
  void onWillMount() {}
  void onDidMount() {}
  void onWillUpdate(RtState state) {}
  void onDidUpdate(RtState state) {}
  void onWillUnmount() {}
  void onDidUnmount() {}
}

Methods

• onCreated : Called when the dependency is created. This is the first lifecycle method invoked.
• onWillMount (only in flutter_reactter): Called just before the dependency is mounted. Useful for pre-mount setup.
• onDidMount (only in flutter_reactter): Called immediately after the dependency is mounted. Ideal for post-mount initialization.
• onWillUpdate : Called before the dependency is updated. The parameter is the state ( RtState ) that triggered the update. Use this to react to state changes before they take effect.
• onDidUpdate : Called after the dependency is updated. The parameter is the state ( RtState ) that triggered the update. Use this to react to state changes after they take effect.
• onWillUnmount (only in flutter_reactter): Called just before the dependency is unmounted. Useful for cleanup tasks.
• onDidUnmount (only in flutter_reactter): Called immediately after the dependency is unmounted. Ideal for final cleanup or resource release.

Example

Here’s an example of a simple RtDependencyLifecycle implementation:

• counter_controller.dart
• counter_view.dart
• counter.dart
• main.dart

import 'package:flutter_reactter/flutter_reactter.dart';

class CounterController extends RtDependencyLifecycle {
  final count = Signal(0);

  void increment() {
    count.value++;
  }

  void decrement() {
    count.value--;
  }

  @override
  void onCreated() {
    print('CounterController initialized');
  }

  @override
  void onDidMount() {
    print('CounterController mounted');
  }

  @override
  void onWillMount() {
    print('CounterController will mount');
  }

  @override
  void onWillUpdate(RtState state) {
    print('CounterController will update by ${state.runtimeType}');
  }

  @override
  void onDidUpdate(RtState state) {
    print('CounterController did update by ${state.runtimeType}');
  }

  @override
  void onWillUnmount() {
    print('CounterController will unmount');
  }

  @override
  void onDidUnmount() {
    print('CounterController did unmount');
  }
}

import 'package:flutter/material.dart';
import 'package:flutter_reactter/flutter_reactter.dart';
import 'counter.dart';

class CounterView extends StatelessWidget {
  const CounterView({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    final showCounter = Signal(false);

    return Scaffold(
      appBar: AppBar(
        title: const Text("Counter - Lifecycle using RtDependencyLifecycle"),
      ),
      body: RtSignalWatcher(
        builder: (context, child) {
          return Center(
            child: Column(
              mainAxisAlignment: MainAxisAlignment.center,
              children: [
                ElevatedButton(
                  onPressed: () => showCounter(!showCounter.value),
                  child: showCounter.value
                      ? const Text('Hide counter')
                      : const Text('Show Counter'),
                ),
                const SizedBox(height: 8),
                if (showCounter.value) const Counter(),
              ],
            ),
          );
        },
      ),
    );
  }
}

import 'package:flutter/material.dart';
import 'package:flutter_reactter/flutter_reactter.dart';

import 'counter_controller.dart';

class Counter extends StatelessWidget {
  const Counter({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    // Provide the `CounterController` dependency to the widget tree
    return RtProvider<CounterController>(
      () => CounterController(),
      builder: (context, counterController, child) {
        return Row(
          mainAxisSize: MainAxisSize.min,
          children: [
            ElevatedButton(
              onPressed: counterController.decrement,
              child: const Icon(Icons.remove),
            ),
            const SizedBox(width: 8),
            // Observe the `count` property of the `counterController`
            // and rebuild the widget tree when the `count` value changes
            RtConsumer<CounterController>(
              listenStates: (counterController) => [counterController.count],
              builder: (context, counterController, child) {
                return Text("${counterController.count}");
              },
            ),
            const SizedBox(width: 8),
            ElevatedButton(
              onPressed: counterController.increment,
              child: const Icon(Icons.add),
            ),
          ],
        );
      },
    );
  }
}

import 'package:flutter/material.dart';
import 'counter_view.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: CounterView(),
    );
  }
}