My question is related to Navigaror 2.0
There is just a link of medium article on official documentation and nothing else.
I want to implement Activity for Result.But in router deligate class I just implemented push,pop,of methods.
How to implement Future in push,pop I didn't find any lead.
Then I explored the packages on pub.dev
go_router
auto_route
Which package you recommend and why??
Both are up-to-date but I want recommendation from community
My choice is go_router since it's reduce complexity, regardless of the platform and Navigator2 structure and support:
mobile, web and desktop
declarative, parameterized routing
deep and dynamic linking
nested navigation
redirection
custom transitions
route debugging
and lastly, it provides rapid and excellent support.
Check out this guide for questions about how to implement Activity for Results:
https://gorouter.dev/user-input
Related
There is setState and moreover Provider, using which you can manage your states easily and neatly, then why Riverpod?,
I see different examples in enter link description here where riverpod is being used, I just find each example making simple things more complicated, when you use Riverpod, same things can be done more easily with Provider or just using setState and following some good techniques while managing states in codes.
there is a package named hooks_riverpod, I don't find the justification of this package just to support riverpod you hacked all the statndard widgets although there is another version flutter_riverpod but using hooks is not an intended approach maybe helpful for people coming from reactjs background but flutter engineers have not designed flutter this way, using these non-standard approaches you are just trapping yourself within the mercy of these few packages.
Inherited widgets is only standard approach given by flutter of managing states across the app, Provider and some other Packages like Redux they just follow the same approach.
If you may have used the Riverpod or related packages please share your experience.
It depends on the project and how you like to handle state. If you are ok with setState management/Inherited widgets, you don't need to use others.
I like share some reference here, On riverpod doc second section you can find
Provider, without its limitations
Riverpod is inspired by Provider but solves some of it's key issues such as supporting multiple providers of the same type; awaiting asynchronous providers; adding providers from anywhere, ...
riverpod, Dart only (NO flutter)
flutter_riverpod, A basic way of using Riverpod with flutter. You mostly use it for state management.
If you are using hook widgets(flutter_hooks) that reduce the boilerplate code like dispose, you can use hooks_riverpod
Also, all these packages provided by same author Remi Rousselet
Well, there's a lot of debate on a good state management solution out there.
But in your context, I'd like to mention some points.
Why Riverpod over Provider?
Well, Riverpod was built to fix some issues of Provider which would have been impossible to fix in Provider.
Like:
Majorly, Riverpod is compile safe.
Solves stuff like multiple providers, adding providers from anywhere.
Removes Flutter dependence, there's no need of using contexts anymore like that were used in Provider.
and others... for more on that you can refer to the home page of Riverpod here
Also, Remi, the creator of Riverpod & Provider suggests using Riverpod over Provider.
Secondly, why not setState?
Well, you can't build a featured application just using setState with proper programming standards. You would have to pass up and down data in your application continuously with Prop Drilling. Imagine having 5 widgets under a parent widget and the parent widget needs the data in the 5th sub widget. This is just a normal case, it could go much worse in actual applications.
About hooks?
Well, yes, it's well easy for React devs to quickly jump on to Flutter. But that's just not the case it was developed for. Its main purpose is to use reusable functional widgets. So, a good example of this will always be, when you're using Animation Controller and you've to maintain its lifecycle every time you use it. I can't go in depth here, for that you can refer to the docs.
I want to know what is the difference between getx and riverpod. I am so confused about which one of these two state management tools I will use in real projects.
Here is a good and very recent YouTube video on the topic:
https://www.youtube.com/watch?v=mxkhUYC5yF8
However, I suggest you to look at BLoC and especially using its cubits.
Riverpod in my opinion is not a good choice since they decided to completely reinvent the wheel, not using InheritedWidget but instead implementing their own solution. I would never want to be working against a framework, but rather with it.
The difference is that Riverpod follows unidirectional data flow and getx doesn't.
go for riverpod for large products,
go for GetX for small applications.
GetX is not just a state managing tool, it more like a framework for flutter. If you only want a state manager you will get all of these extra functions and utilities you don’t need. And if you use all of what GetX have to offer, your entire routing, materialApp, localization, api, etc is dependent on one package. Having your application dependent on both Flutter and GetX to be maintained is an unnecessary gamble imo. Especially if it’s a production app.
So there are a ton of dart packages that do all the heavy lifting regarding API handling but I am looking for the ground-up approach to learning API's and how they are handled within the Flutter framework. Wondering if there are any sources/tutorials on how to do so. With the exception of google's own documentation.
You can go through the official website to handle APIs in flutter-
https://docs.flutter.dev/cookbook/networking/fetch-data
and here's a good documentation of basic flow of API integration-
https://mobikul.com/http-api-calling-in-flutter/
Hope it will work for you.
In a previous Xamarin native application, I used Microcharts, which is a charting library for .net. Using Microcharts, we had the chart-related logic in the shared part (we used MVVM) and just used charting components on each platform. I was wondering if there is any equivalent for Kotlin Multiplatform Mobile? I'd like to have the charting logic in the shared part.
Thanks.
AFAIK there isn't one that you're looking for.
You could still share your charting logic in KMM, exposing all the chart related information to the platform specific Views, then map that data if needed for the specific library you'd use on iOS/Android.
I think it's best if you don't mix view related libraries, since this way you still get the flexibility of choosing any chart library for any platform
I would like to briefly ask something that is perhaps a little strange.
In general, there are several design patterns for developing an app (MVVM, MVC, MVP).
In Flutter there are packages that make state management easier.
Bloc
Cubit
Redux
MobX
Riverpod
flutter_command
Momentum
Flyweight
Flutter Hooks
The question is, can the packages be clearly classified in one of the architecture or is it recommended to implement a certain architecture with the package?
For example, I understood that BLoC follows an MVVM concept, while Momentum uses the MVC pattern. Is that right?
Can someone add to the list for the other packages?
Simply,
No, you can not classify state management mechanisms as a design pattern or architectural pattern. State Management & Architecture are two different things.
Why
Flutter is classified as a declarative framework, which means UI is built again & again based on the current app state ( simply current data/ information). So, Flutter State Management is used to share the app state within the widget tree. That's it.
On the other hand, app architecture is about overall communication among different layers on the app, like how UI talks to controllers, controllers to database, web service, parses, models &, etc