Flutter 3 release, May, 2022
Flutter 3 was released in mid-May, 2022. You can read more about it here on 9to5google.com, and on other websites.
Flutter 3 was released in mid-May, 2022. You can read more about it here on 9to5google.com, and on other websites.
As a brief note, SQLite doesn’t have date/time (datetime) fields, so when you want to use a datetime field with Flutter and Dart, you have to do something else.
My choice was to store my date/time data as a SQLite INTEGER
field. I did this so I can query and sort that field easily myself. The benefit of storing a datetime field as a TEXT
field is that you can read it easier, but I think an INTEGER
field is a little easier to work with, though YMMV.
As a quick Flutter FutureBuilder
note, I wrote a FutureBuilder preferences example, but by the nature of that topic, the code isn’t necessarily simple.
Today I just saw this much simpler FutureBuilder example, so I want to give it props. Besides the clean code, the important concept in that article is that you know that your widget data is coming from an async source — such as a REST call or database access — an you need to know how to handle that.
Filed in the “FWIW” category ... I wrote the following Dart/Flutter code as an attempt to create a Flutter file logger using Dart isolates, but as it turns out, at the time of this writing the Flutter platform won’t let you do that. So I thought I’d share/save my code here in case I can use it in the future.
First, here’s my Flutter file logging code that uses Dart isolates:
When I started working with Flutter a couple of months ago to develop iOS and Android apps from one code base, I started keeping notes about how to do things with Flutter and Dart (the programming language behind Flutter). These notes became my own personal cheatsheet, and then those notes just kept getting larger, and larger.
From there, I started to create a book I titled “Flutter Quick Reference” based on those notes. Right now this “book” is really just a very large Flutter/Dart cheatsheet, but because some of the content in it can’t be found elsewhere on the internet, I thought I’d share it here. Also, because I don’t know if I’ll ever take the time to finish making this into a real book, I made this first release free.
I’m creating this page as a collection of Flutter source code snippets. These are early days, but here you go.
Note also that my Flutter Quick Reference has many more examples as well.
Here’s a link to my Flutter replacement home page code.
This may not make sense to most people, but if you ever want a simple replacement Flutter “home page” for a new app, this should work. All it does is create a home page with a ListView
, and you can use those ListView
items as simple menu items to get started with.
I also added a FloatingActionButton
in case you want that to start with as well. Note that you’ll probably want to remove the @dart
line for modern Flutter apps. (I’ll try to remember to update this code the next time I use it.)
I prefer this to the default home page you get when running flutter create my_app
. My goal is to be able to highlight the default Flutter home, delete that code, and replace it with this code as a simple starter menu.
Here’s the code:
In one of the crazier bugs I’ve seen, I got to a point where I had my Flutter app in good shape, and I had been testing it on an Android device. So as one last test I wanted to make sure I deleted the app from the Android device — a Kindle Fire tablet — so I could then do a complete reinstall of my app so I could give it one more quick test.
And then it never installed properly.
It seemed like the app started to install on my Android device, but then it wouldn’t. I tried all sorts of different flutter run
commands, but the app just wouldn’t install. It seemed a little like it was hung up (stalled), but it also seemed a little like it also finished installing and was sitting there waiting for me. (At the moment I don’t remember the exact messages the Flutter build process was showing.)
As a brief note today, if you ever need to debug some Dart/Flutter code to see how much time some code is taking, here’s a manual approach that you can use to determine the “delta time” between two statements:
final t1 = DateTime.now(); // the source code you // want to test is in here final t2 = DateTime.now(); debugPrint('DELTA TIME: ${t2.difference(t1)}');
I just used this code to find a significant bottleneck, so while it’s not as sophisticated as other techniques, it was a nice performance-debugging tool today.
As a brief note to self, the Dart/Flutter filter
method on a List
is actually named where
. I’m used to this type of method being named filter
in other programming languages, but where
is cool, too. Here’s a one-line where
example:
final List<File> files = entities.where((e) => (e is File)).toList();
FWIW, in Scala that code would use a filter
method instead of where
, and look like something like this:
val files: List<File> = entities.filter(e => e.isFile));
Or more simply, like this:
val files = entities.filter(_.isFile));
But getting back to my point, Dart/List/filter is really Dart/List/where.
One thing I like about using Flutter to build mobile apps is that like Scala, it’s low-ceremony: every character has a purpose that isn’t redundant. It’s also a modern take on creating UIs, where your code is just widgets, event-handling, and custom logic.
For example, with a little extra file/directory logic that’s not shown here, this code is all you need to list the files in a directory on both iOS and Android devices.
As a brief note, these are two different ways to do a “sleep” call in Flutter/Dart, depending on your needs:
// inside an async method await Future.delayed(const Duration(milliseconds: 250)); // not in an async method sleep(const Duration(milliseconds: 250));
As shown, the first approach is for when you want an async/await approach, and the second sleep method is for when you are doing things in serial order (as opposed to a parallel/concurrent approach).
One of the keys when writing Flutter code is to know when to call the setState
method. As a quick answer, the Flutter docs state:
As a brief note, I ended up not using the following code, but if you ever need to use the Flutter url_launcher library with the Flutter Html
widget’s onLinkTap
method, this code should work for you:
I’m generally getting out of the writing business, but that being said, I don’t mind sharing some code as I go along. In this case I created the follow Dart programming examples as I reload Dart into my brain:
As a note to my Future Self, any time you’re working with Flutter and you want to try to make initState
or build
an async
method — or try to use the then
method on a Future
inside initState
or build
— what you probably really want is to use a FutureBuilder
inside the build
method, something like this:
As a quick note, here are a couple of examples of how to simulate a slow-responding Flutter/Dart method:
Future<bool> _getFutureBool() {
return Future.delayed(Duration(milliseconds: 500))
.then((onValue) => true);
}
Future<bool> getEnableNotifications() async {
final SharedPreferences prefs = await SharedPreferences.getInstance();
return Future.delayed(const Duration(milliseconds: 1000), () {
return prefs.getBool(KEY_ENABLE_NOTIFICATIONS) ?? false;
});
}
As shown, the first example uses Future.delayed
followed by a then
call, and the second example shows Future.delayed
with a lambda function.
You’ll want to use this code/technique when you’re working with Flutter futures and its FutureBuilder
class.
I was reminded about the need to test things likes futures and FutureBuilder
when some code I found on the internet wasn’t working properly. As a result I wrote my tutorial, How to correctly create a Flutter FutureBuilder.
As a brief note, sometimes in Flutter (and Dart) you have to write a method/function that makes an asynchronous call, but the method can’t be marked async
itself. The Flutter initState
method is a good example of this.
So far I’ve learned two ways to deal with this:
then
inside the non-async methodI’ll demonstrate each technique below.