Google's Flutter is an open-source UI (User Interface) framework. It enables the creation of cross-platform mobile, web, and desktop applications from a single codebase. Here's a basic overview of Flutter:
Dart Programming Language: Dart is the programming language used by Flutter. Dart is a modern, object-oriented programming language with features such as a just-in-time (JIT) compiler that allows for rapid development and efficient performance.
Widgets: Flutter is built on a reactive and component-based design, and your UI is built with widgets. Widgets are the foundation of a Flutter application and can be used to create elaborate user interfaces. Flutter has a large number of basic and specialized widgets.
Flutter's hot reload capabilities is one of its standout characteristics. It enables you to see changes to your code immediately reflected in the app without having to restart it. This greatly accelerates the development process.
Cross-platform Development: Flutter allows you to create apps for many platforms such as Android, iOS, web, and desktop. You may target several platforms with a single codebase, minimizing development time and effort.
Material Design and Cupertino: Flutter comes with two pre-designed widget collections: Material Design and Cupertino. Material Design widgets adhere to Google's design guidelines, resulting in a modern and visually appealing user interface. Cupertino widgets mimic the iOS native look and feel, making it easy to create apps that look like they're from iOS.
Access to Native Device capabilities: Flutter allows you to use plugins to gain access to native device capabilities and APIs. It has a broad ecosystem of plugins that cover a wide range of functions, including camera access, location services, and network requests.
Performance: Flutter apps are well-known for their high performance. Flutter creates its own widgets using a rendering engine, resulting in fluid and responsive user interfaces. Furthermore, the Dart programming language and Flutter framework optimize performance through the use of just-in-time (JIT) and ahead-of-time (AOT) compilation techniques.
Community and Support: Flutter has an active and lively community. There are several tools, courses, packages, and sample code available online. The community actively contributes to the framework's progress and offers assistance through forums, Stack Overflow, and other channels.
- createState()
- mounted == true
- initState()
- didChangeDependencies()
- build()
- didUpdateWidget()
- setState()
- deactivate()
- dispose()
- mounted == false
In a nutshell: performance.
The short version is that 'state' objects live a long time, but stateful widgets are discarded and rebuilt anytime the configuration changes. Rebuilding a changeable widget is incredibly cheap for Flutter.
It is capable of constantly constructing its widget in response to data changes and as needed.
When flutter is told to create a stateful widget, it immediately runs createState().
This method must exist. A stateful widget rarely has to be more sophisticated than this. Here's an example:
class HomeScreen extends StatefulWidget {@override
HomeScreenState createState() => HomeScreenState();
}
The state class is created by createState, and it is given a buildContext.
The place in the widget is placed in an unnecessarily simplistic BuildContext. Here's a more detailed explanation.
The attribute 'bool this.mounted' is shared by all widgets. When the buildContext is assigned, it becomes true. When a widget is unmounted, calling setState is an error.
When the widget is built, this is the first method that is called.
initState is called only once. It also has to call super.initState().
This @override technique is ideal for:
2. Set properties that are dependent on this widget's 'parent' in the tree.
3. Subscribe to Streams, ChangeNotifiers, or any other object that has the potential to update the data on this widget.
@override
void initState() {
super.initState();
}
On the first time the widget is constructed, the didChangeDependencies method is called immediately after initState.
It will also be invoked anytime an object on which this widget relies for data is called. For example, if it is dependent on an InheritedWidget that updates.
Because build is always called after didChangeDependencies, this is rarely necessary. However, this is the first change you must make before calling BuildContext.inheritFromWidgetOfExactType. This would essentially make this State 'listen' to updates on a Widget from which it is inheriting data.
It may also be beneficial if you need to perform network calls (or any other expensive operation) when an InheritedWidget updates, according to the documentation.
didUpdateWidget() is called when the parent widget changes and wants to rebuild this widget (because it needs to provide it different data), but it is rebuilt with the same runtimeType.
This is due to Flutter reusing the long-lived state. In this scenario, re-initializing certain data, as in initState(), is required.
If the state's build() method relies on a Stream or other object that can change, unsubscribe from the old object and re-subscribe to the new one in didUpdateWidget().
@overridevoid didUpdateWidget(Widget oldWidget) {
if (oldWidget.importantProperty != widget.importantProperty) {
init();
}
}
void updateProfile(String name) {
setState(() => this.name = name;
}
8. deactivate()
This is rarely used.
'deactivate()' is called when State is removed from the tree, but it may be reinserted before the current frame change is completed. This method exists primarily because State objects can be relocated from one place in a tree to another.
When the State object is permanently eliminated, 'dispose()' is called.
This is where you unsubscribe and cancel all animations, streams, and so on.
Comments
Post a Comment