The complexity is simplified and easy to manage.
FBroadcast helps developer build an efficient broadcast system in the application and supports sticky broadcast.
Author：CoorChice(coorchice.cb@alibaba-inc.com)
**English | [简体中文](https://github.com/Fliggy-Mobile/fbroadcast/blob/master/README_CN.md)**
> Like it? Please cast your **Star** 🥰 ！
# ✨ Features
Let’s take a look at **FBroadcast** that provides developer with incredible capabilities:
- Support **send** and **receive** specified types of messages
- Message support to carry **any type** data packets
- Provided **Context Bind**, one line of code can remove all receivers in the context
- Incredible **Sticky Broadcast**
- **Two-way communication** support
- Easy to build simple and clear local and global state management
# 🛠 Guide
**FBroadcast** is an efficient and flexible **Broadcasting System** that can help developer **easy and orderly** build **associated interaction** and **state changes** with great complexity、beautiful application.
**FBroadcast** will bring those obvious changes to building complex and beautiful application?
- **Complete decoupling between Widget/Module**
Through the **FBroadcast** efficient broadcast system, developer can easily complete the decoupling of **Widget/Module**. When building an application, it is often necessary to change the state or data between **Widget/Modules A, B, C, ..** according to interactive operations. Developer have to make each **Widget/Module depend on each other for this purpose**, or create a **Unified State Manager** for them, which can solve the problem, but it makes the build cumbersome and also makes the change difficult.
**FBroadcast** has established a **simple, effective, and clear** broadcasting system, so that changes at any time/location in any **Widget/Module** can be actively broadcast, and it needs to be broadcast based on these. The **Widget/Module** that changes **response or updates the view** only needs to register the corresponding **information receiver**, and it can receive the message and respond when the change occurs. This makes the associated modules no longer need to depend on each other, or design and establish a unified state manager for them.
**Very simple, lightweight, and easy to change**. When a **Widget/Module** no longer needs to be updated according to the changes of another **Widget/Module**, just remove the **receiver** in it, instead of making major changes **Dependency** or **State Manager**.
- **Simple, flexible, clear and easy to manage**
**FBroadcast** provides developer with the ability to send broadcasts and register/remove receivers at any time, without restriction and flexibility.
The broadcast and the receiver confirm each other's identities through a clear type (string), and the specified type of broadcast can only be received by the specified type of receiver.
**FBroadcast** provides environment registration support. Developer can remove all types of receivers in the environment at one time through the [unregister()] function when the environment is deconstructed, without having to remember and care about which receivers need to be removed. . For example, the developer can remove all receivers registered in the **Widget** in the `dispose()` of **Widget**.
With the capabilities of modern IDEA, developer can create a unified broadcast type index table (or multiple) for the broadcast system. Through the reference index of IDEA, developer can easily , It can be seen at a glance that this type of broadcast has been sent in those places, and the receivers are registered in those places, which is very easy to manage and maintain. The use of character strings as type identifiers allows developer to describe the meaning of different types of broadcasts clearly enough.
- **Sticky Broadcast Support**
**FBroadcast** provides support for sending **sticky broadcast**. In the case that no receiver has been registered, the developer can send a **sticky broadcast** in advance when the event occurs. **Sticky Broadcast** will be temporarily stuck in the broadcast system, and when a receiver is registered, it will broadcast immediately. This helps developer to adopt clearer and more effective thinking when doing logic design.
For example, when the switch button in a control module is turned on, and the module controlled by the switch has not been built yet, you can send a **sticky broadcast** first, and after the module is built and the receiver is registered, It will immediately receive the **sticky broadcast** and enter the open state (this is essentially different from the idea of mutual dependence, defining unified state management or parameter transfer, and then checking the switch state).
## 📡 Base Broadcast
Register through **FBroadcast**, sending broadcast is very easy.
```dart
/// register
FBroadcast.instance().register(Key_Message, (value, callback) {
/// do something
});
/// send message
FBroadcast.instance().broadcast(Key_Message);
```
**FBroadcast** allows developer to include data when sending messages.
```dart
/// register
FBroadcast.instance().register(Key_Message, (value, callback) {
/// get data
var data = value;
});
/// send message and data
FBroadcast.instance().broadcast(
/// message type
Key_Message,
/// data
value: data,
);
```
Developer can choose to persist specific types of messages, so that they can easily implement broadcast-style global state management.
```dart
FBroadcast.instance().broadcast(
/// message type
Key_Message,
/// data
value: data,
/// Persist the message types
persistence: true,
);
```
After the developer persists a message type, he can use `FBroadcast.value(String key)` to get the latest data of the message type in the broadcast system at any location. The update of the data in the broadcast system only needs to be done through `broadcast()`.
> ⚠️Note that once a message type is persisted, it can only be removed from the broadcast system through `FBroadcast.instance().clear(String key)`.
## 🧲 Sticky Broadcast
**FBroadcast** allows developer to send **Sticky Broadcasts**.
```dart
FBroadcast.instance().stickyBroadcast(
/// message type
Key_Message,
/// data
value: data,
);
```
When there is no corresponding type of receiver in the broadcast system, **sticky broadcast** will temporarily stay in the system until a receiver of this type is registered, and the broadcast will be sent out immediately (when there is a corresponding type in the broadcast system The receiver has the same performance as ordinary broadcast).
## ⛓ Two-way communication
**FBroadcast** supports receiving messages returned by **receiver** at the broadcast sending point.
```dart
/// send message
FBroadcast.instance().broadcast(
/// message type
Key_Message,
/// data
value: data,
/// The message returned by the receiver
callback: (value){
// do something
}
);
/// register
FBroadcast.instance().register(Key_Message, (value, callback) {
/// get data
var data = value;
/// do something
var result = logic();
/// return message
callback(result);
});
```
Through **FBroadcast**, two-way communication can be realized very easily.
## 🌏 Bind Context
**FBroadcast** supports passing in an **environment object (can be of any type)** when registering the receiver, which will register the receiver in the environment. When the environment is deconstructed, developer can easily move it all at once. Except for all receivers registered in the environment.
```dart
/// register
FBroadcast.instance().register(
/// Message type
Key_Message1,
/// Receiver
(value, callback) {
/// do something
},
/// more receiver
more: {
/// Message type: Receiver
Key_Message2: (value, callback) {
/// do something
},
Key_Message3: (value, callback) {
/// do something
},
Key_Message4: (value, callback) {
/// do something
},
},
/// context
context: this,
);
/// Remove all receivers from the environment
FBroadcast.instance().unregister(this);
```
## 👀 Example
### 💫 Messaging
**Scene**: Click **Start**, the Runner starts Run, and the display needs to update the status of the athlete in real time.
#### 🏃 1. Create Runner:
```dart
/// Runner
class Runner {
Runner() {
/// register
FBroadcast.instance().register(Key_RunnerState, (value, callback) {
if (value is String && value.contains("Run")) {
/// receive start run message
FBroadcast.instance().broadcast(Key_RunnerState, value: "0m..");
run(20);
}
});
}
run(double distance) {
/// send running message
Timer(Duration(milliseconds: 500), () {
FBroadcast.instance().broadcast(Key_RunnerState, value: "${distance.toInt()}m..");
var newDistance = distance + 20;
if (newDistance > 100) {
FBroadcast.instance().broadcast(Key_RunnerState, value: "Win!\nTotal time is 2.5s");
} else {
run(newDistance);
}
});
}
}
```
#### 🍭 2. Create UI:
```dart
Column(
mainAxisAlignment: MainAxisAlignment.center,
children: 