Stream in Flutter

Type of Streams 

There are two types of streams.

1. Single Subscription
2. Broadcast

Single Subscription

These streams allow only a single listener to be attached. Once a listener is attached to the stream, no other listeners can be added. These streams follow a one-to-one relationship with their listeners. They are often used when you want to ensure that a piece of data is consumed by only one entity.

Broadcast

On the other hand, supports an infinite number of listeners. You can attach multiple listeners to the same broadcast stream, and each listener will receive the same events or data as they occur. Broadcast streams are ideal when you need to share data or events among multiple components of your application.

Difference between Single Subscription and Broadcast

Managing Stream Data

We can manage the stream data in the following ways:

Subscription Management

• Utilize the listen() method from StreamSubscription to subscribe to a stream and receive emitted events or values.
• Keep track of the subscription object returned by listen() to effectively manage it, including canceling it when it's no longer needed.
• Use the cancel() method to terminate a subscription, cease listening to the stream, and release any associated resources.

Stream Completion

• Be aware that streams can reach a point of completion, indicating that no further values will be emitted.
• Employ the onDone callback in listen() or within the StreamSubscription to handle stream completion and perform any necessary cleanup tasks.

Error Handling

• Address errors that occur during stream processing by utilizing the onError callback in listen() or the StreamSubscription.
• Implement appropriate error-handling logic within the callback to gracefully manage errors and prevent potential application crashes.

Resource Cleanup

• Properly manage resources that are linked to the stream, such as closing network connections, releasing file handles, or disposing of system resources.
• Trigger cleanup operations and resource release using the onDone callback when the stream reaches completion.

Multiple Subscribers

• Streams in Flutter support multiple subscribers, enabling multiple listeners to monitor the same stream concurrently.
• Each subscriber independently receives emitted events and processes them based on their unique logic.

Example Application

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

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

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

  @override
  Widget build(BuildContext context) {
    return const MaterialApp(
      home: CounterScreen(),
      debugShowCheckedModeBanner: false,
    );
  }
}

class CounterScreen extends StatefulWidget {
  const CounterScreen({Key? key}) : super(key: key);

  @override
  _CounterScreenState createState() => _CounterScreenState();
}

class _CounterScreenState extends State<CounterScreen> {
  late StreamController<int> _streamController;
  late Stream<int> _counterStream;
  late Timer _timer;
  int _counter = 0;

  @override
  void initState() {
    super.initState();
    _streamController = StreamController<int>();
    _counterStream = _streamController.stream;
    _startCounting();
  }

  @override
  void dispose() {
    _streamController.close();
    _timer.cancel();
    super.dispose();
  }

  void _startCounting() {
    const duration = Duration(seconds: 1);
    _timer = Timer.periodic(duration, (_) {
      _counter++;
      _streamController.add(_counter);
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Stream Counter'),
      ),
      body: Center(
        child: StreamBuilder<int>(
          stream: _counterStream,
          builder: (context, snapshot) {
            if (snapshot.hasData) {
              return Text(
                'Count: ${snapshot.data}',
                style: const TextStyle(fontSize: 24),
              );
            } else {
              return const CircularProgressIndicator();
            }
          },
        ),
      ),
    );
  }
}

Output

Advanced Stream Operations

It involves combining streams, transforming stream data, and applying stream transformers. Stream combination enables the merging or concatenation of multiple streams, while stream transformation allows you to modify or filter the data emitted by a stream. Stream transformers provide a powerful way to perform complex operations on streams.

Testing and Debugging Streams

Unit testing is crucial when working with streams. Test various scenarios to ensure that your streams behave as expected. Debugging tools and techniques can help you identify stream behavior issues, ensuring your application's stability and reliability.

Frequently Asked Questions

What is a Stream in Flutter?

A stream in Flutter is an asynchronous data flow mechanism that emits a sequence of events over time, such as data or error signals.

How Many Streams Are in Flutter?

Flutter supports two types of streams: Single Subscription Streams (for one listener) and Broadcast Streams (for multiple listeners simultaneously).

What is the Difference Between Stream and Future in Flutter?

A Future resolves a single value asynchronously, while a Stream delivers a sequence of multiple asynchronous events over time.

Conclusion

Streams are like powerful tools in Flutter's toolbox for creating dynamic apps. They help manage events that happen over time, making it easy to keep your app updated in real-time. By using streams, you can make your app more interactive, responsive, and efficient. 

So now that you know about Stream in Flutter, you can refer to similar articles.

• Flutter Bloc
• Streams 
• Flutter Interview Questions

You may refer to our Guided Path on Code360 to enhance your skill set on DSA, Competitive Programming, System Design, etc. Check out essential interview questions, practice our available mock tests, look at the interview bundle for interview preparations, and so much more!