Mastering Flutter Streams: Exploring Single and Broadcast Streams

Flutter, Google’s UI toolkit, is renowned for its expressive and flexible framework that allows developers to build natively compiled applications for mobile, web, and desktop from a single codebase. One powerful feature in Flutter is the use of streams, which enable efficient and asynchronous communication between different parts of your application. In this article, we’ll delve into the concept of streams in Flutter, specifically focusing on Single and Broadcast Streams. Additionally, we’ll explore the implementation of a custom stream function to deepen our understanding.

Overview of Streams in Flutter

Streams are a fundamental part of the Dart language, and Flutter leverages them to handle asynchronous programming. A stream is a sequence of asynchronous events, and it allows the components of your application to communicate without blocking the execution. Streams are crucial for handling user input, network requests, and other asynchronous tasks in a Flutter application.

In Dart, there are two types of streams: Single Subscription Streams and Broadcast Streams.

Single Subscription Streams

Single Subscription Streams allow only one listener to listen to the stream. Once a listener is subscribed, no other listeners can subscribe to the same stream. It is suitable for scenarios where you want to ensure that only one consumer is processing the stream events.

import 'dart:async';

void main() {
  // Creating a Single Subscription Stream
  StreamController<int> singleController = StreamController<int>();

  // Adding a listener to the stream
  StreamSubscription<int> subscription = singleController.stream.listen(
    (data) {
      print('Received: $data');
    },
  );

  // Adding data to the stream
  singleController.add(1);
  singleController.add(2);
  singleController.add(3);

  // Closing the stream
  singleController.close();
}

Broadcast Streams

On the other hand, Broadcast Streams allow multiple listeners to subscribe to the same stream. This is useful when you want to broadcast events to multiple parts of your application simultaneously.

import 'dart:async';

void main() {
  // Creating a Broadcast Stream
  StreamController<int> broadcastController = StreamController<int>.broadcast();

  // Adding the first listener to the stream
  StreamSubscription<int> subscription1 = broadcastController.stream.listen(
    (data) {
      print('Listener 1 Received: $data');
    },
  );

  // Adding the second listener to the stream
  StreamSubscription<int> subscription2 = broadcastController.stream.listen(
    (data) {
      print('Listener 2 Received: $data');
    },
  );

  // Adding data to the stream
  broadcastController.add(1);
  broadcastController.add(2);
  broadcastController.add(3);

  // Closing the stream
  broadcastController.close();
}

Creating a Custom Stream Function

Now, let’s explore how to implement a custom stream function in Flutter. Suppose we want to create a stream that emits a sequence of Fibonacci numbers. We can achieve this by creating a custom stream function.

import 'dart:async';

// Custom Stream Function to generate Fibonacci numbers
Stream<int> generateFibonacci(int count) async* {
  int a = 0, b = 1;
  for (int i = 0; i < count; i++) {
    yield a;
    int temp = a + b;
    a = b;
    b = temp;
  }
}

void main() async {
  // Creating a custom stream for Fibonacci numbers
  Stream<int> fibonacciStream = generateFibonacci(5);

  // Listening to the custom stream
  await for (int value in fibonacciStream) {
    print('Fibonacci: $value');
  }
}

In this example, the generateFibonacci function returns a stream of Fibonacci numbers based on the specified count. The async* syntax is used to create a generator function that yields values asynchronously. The await for loop is then used to listen to the stream and print the generated Fibonacci numbers.

Conclusion

Understanding streams in Flutter is crucial for developing responsive and efficient applications. By leveraging streams, developers can handle asynchronous events seamlessly. Additionally, creating custom stream functions allows for the implementation of tailored solutions to meet specific application requirements.

As you continue to explore Flutter, experimenting with streams will provide you with a powerful tool-set for building dynamic and interactive applications.

Stackademic

Thank you for reading until the end. Before you go:

• Please consider clapping and following the writer! 👏
• Follow us on Twitter(X), LinkedIn, and YouTube.
• Visit Stackademic.com to find out more about how we are democratizing free programming education around the world.