#reorderablelistview

[flutter-video]

‏‎#ReorderableListView #Flutter #Widget ‎‏ https://www.instagram.com/p/CAszQGXn2mY/?igshid=19rnt0y6599c9

[flutteragency]

How to Use ReorderableListView Widget in Flutter App Development?

The Flutter Agency concentrated on the most commonly used widgets when designing and developing mobile applications. Developers can start constructing beautiful apps or consult a Flutter app development company if they have a rudimentary understanding of Flutter widgets.

In this article, We will look at Flutter’s Reorderable ListView and how to reorder a list item. You can reorder the items on a ListView in your flutter apps using the ReorderableListView widget.

ListView is a linearly ordered scrollable list of widgets. Furthermore, it scrolls through its children one by one. You can learn more about ListView widget in our article.

Let’s look at how to make a flutter ReorderableListView. You can also discuss this with a dedicated Flutter mobile app developer at Flutter Agency.

The Constructor for ReorderableListView Widget will look like below :

ReorderableListView({ Key? key, required List children, required this.onReorder, this.itemExtent, this.prototypeItem, this.proxyDecorator, this.buildDefaultDragHandles = true, this.padding, this.header, this.scrollDirection = Axis.vertical, this.reverse = false, this.scrollController, this.primary, this.physics, this.shrinkWrap = false, this.anchor = 0.0, this.cacheExtent, this.dragStartBehavior = DragStartBehavior.start, this.keyboardDismissBehavior = ScrollViewKeyboardDismissBehavior.manual, this.restorationId, this.clipBehavior = Clip.hardEdge, })

Flutter’s ReorderableListView widget allows us to construct list views with elements that can be relocated and reordered by dragging and dropping.

Let’s look at how to make a flutter ReorderableListView.

Step 1: Create a flutter project first.

Step 2: Next, we’ll make a list. As a result, we’ll make a list of strings.

List dataList = ["Data1", "Data2", "Data3", "Data4", "Data5", "Data6", "Data7", "Data8"];

Step 3: Insert a ReorderableListView() widget and a key in the ReorderableListView widget’s children. The key should be able to tell the items apart after they’ve been moved around.

ReorderableListView(children: [], onReorder: (a,b){}),

Step 4: Include a reordering function. The list uses a callback function to notify the application that a list item has been dragged to a new location in the list and that the order of the things should be updated.

onReorder: (a, b) {}

Let’s see a full example of ReorderableListView().

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: MyHomePage(),    );  } } class MyHomePage extends StatefulWidget {  const MyHomePage({Key? key}) : super(key: key);  @override  State createState() => _MyHomePageState(); } class _MyHomePageState extends State with TickerProviderStateMixin {  final List dataList = [    "Data1",    "Data2",    "Data3",    "Data4",    "Data5",    "Data6",    "Data7",    "Data8",    "Data9",    "Data10"  ];  @override  Widget build(BuildContext context) {    return Scaffold(      appBar: AppBar(        title: const Text('Reorderable ListView'),      ),      body: ReorderableListView.builder(          itemCount: dataList.length,          itemBuilder: (context, index) {            final String productName = dataList[index];            return Card(              key: ValueKey(productName),              color: Colors.green,              elevation: 1,              margin: const EdgeInsets.all(5),              child: ListTile(                contentPadding: const EdgeInsets.all(5),                title: Text(                  productName,                  style: const TextStyle(fontSize: 18),                ),              ),            );          },          onReorder: (oldIndex, newIndex) {            setState(() {              if (newIndex > oldIndex) {                newIndex = newIndex - 1;              }              final element = dataList.removeAt(oldIndex);              dataList.insert(newIndex, element);            });          }),    );  } }

To compile and run the above code to need an actual device or an android emulator, read our article on how to set up an emulator for VSCode to set up an Android emulator easily.

After running your code, you can check the item position by long-tapping on an item.

Output

Conclusion

In this article, we have explained the basic demo of ReorderableListView. You can update this code to suit your needs, and this has been a brief introduction to ReorderableListView from our side.

Source:  https://flutteragency.com/use-reorderablelistview-in-flutter/

[blog-by-raika]

【 Flutter 】Flutter を 基礎 から 学習 ( ウィジェット編 ) part100 Interaction model widgets

【 Flutter 】Flutter を 基礎 から 学習 ( ウィジェット編 ) part100 Interaction model widgets

「 基礎 から 学ぶ Flutter 」という書籍で  学習 したことを ブログでアウトプットしていこうと思います。今回は ウィジェット編 ( part100 )です。 前回 【 Flutter 】Flutter を 基礎 から 学習 ( ウィジェット編 ) part99 Interaction model widgets 引き続き、Interaction model widgetsについて学びます。 Interaction model widgets ReorderableListViewウィジェット ReorderableListViewウィジェットはユーザーがリストを任意の順番で並び変えることができるウィジェットです。 リストアイテムを長押しして好きな位置にアイテムを移動できます。 import 'package:flutter/cupertino.dart'; import…

[aksbrillmindz]

flutter 2 with support from multiple platform

Google held a event called but flutter engage where they release the second version of flutterit has the same base of cross platform development but this is with the similar code base this version of flutter does not only build apps for mobile but also has the ability tomanage apps for web desktop and foldables 

so let's start exploring the flutter 2

Flutter has a very good web support

The largest declaration in Flutter 2 is the production-quality site support. Previously, the web was built on a document-centric basis. However, the web platform has evolved to allow for the distribution of richer platform APIs that enable extremely sophisticated applications to use hardware-accelerated 3D and 2D graphics, paint APIs, and versatile layout.

Flutter's web support lays the groundwork for these advancements, offering an app-focused platform that takes full advantage of everything the new web can have to offer. This update initially focuses on three app scenarios.

singer page app

progressive web app

bringing current apps to web

Google primarily focused on rendering fidelity improvements and efficiency. They added a new CanvasKit-based WebAssembly rendered.

They also included web-specific features such as URL control in the address bar, text autofill, PWA manifests, and routing. A Connection Widget was also included to ensure that a smartphone app running in the browser feels like a web app.

Flutter desktop support

Flutter's desktop support can be used as a deployment target for all Flutter apps by Google. Many improvements have been made to bring Flutter desktop up to par, including ensuring that text editing works like a native experience on all supported platforms and adding foundational features such as text selection pivot points.

The TextFormField and TextField widgets for Cupertino and Material design languages now have a built-in background menu. In addition, the ReorderableListView widget now has grab handles. This widget has always been great at shifting stuff around with a developer's minimal effort.

Another improvement for platform-idiomatic features that shows precisely for the desktop form-factor is an improved scrollbar. The revamped scrollbar widget includes a number of engaging features that are similar to those found on the screen, such as the ability to click on the track to page up and down and drag the thumb to show a track when the mouse flutters over it.

Flutter 2 adds command-line argument management to Flutter apps, allowing simple actions like double-clicking a data file in Windows File Explorer to open it in your app.

Furthermore, Google has updated its documentation on what developers to do to prepare their desktop applications for deployment to OS-specific stores.

If you continue to use the desktop beta but remain on the stable channel, you won't get new bug fixes or features as quickly as if you switched to the dev channels or beta. As a result, if you want to deliberately target Linux, macOS, or Windows, you can switch to a platform that provides quicker updates.

extended portability

Flutter is increasingly being used on platforms other than the web and traditional mobile devices. Google highlighted three collaborations that demonstrate Flutter's enhanced portability.

To begin, Canonical and Google are collaborating to bring Flutter to the desktop, with developers providing code to support deployment and creation on Linux. Canonical aims to provide dependable, beautiful experiences through a wide range of hardware configurations. And Flutter is their go-to framework for new mobile and web applications.

Second, Microsoft will expand its Flutter support. Microsoft will add contributions to the Flutter engine that help the increasing class of foldable Android devices, in addition to the existing partnership for providing premium quality Windows support in Flutter. These devices usher in new design trends, with apps that can either take advantage of the dual-screen nature of these devices to provide side-by-side experiences or expand content.

Finally, Toyota, the world's best-selling vehicle maker, announced its plans to introduce best-in-class digital experiences to cars through Flutter-enabled infotainment systems.

Flutter Fix Flutter repair is a combination of a few items. Dart Fix, an exclusive command-line alternative to the Dart CLI tool, knows where to look for a list of deprecated APIs and how to upgrade code that uses those APIs. Then there's the list of open fixes that comes with version 2 of the Flutter SDK.

Finally, it's an improved collection of Flutter extensions for IntelliJ, VS Code, and Android Studio IDEs that can show a similar list of usable solutions, such as quick fixes with little light bulbs that can help developers change their codes with their mouse.

Flutter Folio

How is it possible to write an app that adapts to multiple form factors (large, small, and medium screens), numerous idioms (desktop, web, and mobile), and various input modes (mouse, keyboard, and touch) when Flutter only supports three platforms (iOS, Android, and the web) for production apps and three more in beta (Linux, macOS, and Windows)? The scrapbooking app Flutter Folio was commissioned by Google to address this query.

Folio is a simple example of an application that can operate on several platforms using a single codebase. This app is referred to as platform adaptive because it adapts to the platform it is running on.

add to app

Developers will now benefit from Flutter by incorporating it into their existing Android and iOS applications. This functionality is called Add-to-App, and it's a perfect way to reuse Flutter code in all platforms while keeping the existing native codebase. On the beta channel, the latest APIs that allow this are in preview.

These APIs, as well as a collection of sample projects demonstrating this new trend, are documented on flutter.dev. Google will now recommend using various instances of the Flutter engine in native apps as a result of this update.

Conclusion

Flutter 2 has been released for easy usage of Android app and making Android apps easy other than that it also helps us to build apps for multiple platform we have noted the release of the new version of Flutter and brillmindz oone of the best mobile app development companies in Dubai are waiting to explore the feature

[impurelight]

Two Weeks With Flutter

For the two last weeks I've been playing around with Flutter which is a framework for building Android and iOS apps (it also has Web/Windows/Mac/Linux/ChromeOS support in development). And I really like it. I mean, I didn't always like it. When I first picked it up I thought it was needlessly complicated and frustrating. But as I started to learn what the things actually did I started to think it wasn't so bad. It might even be fun. But I guess that's the way with most programming frameworks.

So Flutter makes Android and iOS apps. How'd you expect it to do this? Probably something like HTML, right? Nope. Flutter uses Dart. The way it knows what to build is you have to override the the build() method and make it return your entire UI. The entire UI in one method. Yeah... that's going to get messy fast. Just take a look at one of my build() methods.

Widget build(BuildContext context) { return Scaffold( body: SafeArea( child: Stack( children: <widget>[ FutureBuilder<list>>( future: DatabaseManager.getAllTasksAsTasks(), builder: (BuildContext context, AsyncSnapshot<list>> tasks) { if (tasks.hasData) { return ReorderableListView( children: createWidgets(tasks.data), onReorder: (int start, int current) {}, ); } else { return Center(child: CircularProgressIndicator()); } }, ), Container(color: Color.fromRGBO(0, 0, 0, 0.4)), Hero( tag: "TaskCreate", child: new AlertDialog( title: const Text('Create Task'), content: new TextField( controller: textController, autofocus: true, ), actions: <widget>[ new FlatButton( onPressed: () { Navigator.of(context).pop(); }, textColor: Theme.of(context).primaryColor, child: const Text('Create'), ), ], )), ]// This trailing comma makes auto-formatting nicer for build methods. ) ) ); }

Yeah, I tried to move some things to their own methods (or classes which is more performant but you really only have to worry about that once you call setState()) but there's only so much you can do and so much you have time to do. If some normal person saw this they would probably say it's ugly. And to be honest when I first saw something like this I thought it was ugly too. It's even more messy if you try adding something to it. Paste your text, watch the entire thing go red, then try to add the end bracket in just the right spot (although a better way appears to be cut the old code, create the old container, and paste the old code). But as I got to know how it worked there was something actually pretty elegant about this.

It's sort of like designing something with Legos. You have your root UI, your scaffold, and that can have a child which is a list view and a floating action button. Only instead of Legos they're widgets. There's widgets for almost everything: list views, cards, centered content, images, text, etc. And if you can't find a widget that serves your purposes you can find one on pub.dev or code your own.

So apart from Widgets there's scenes... no views... I mean routes. OK, different frameworks call them different things. Basically just a page of your app. In Flutter they're called routes. In Unity they're called scenes. And the way Flutter handles routes is pretty interesting. It's like a stack of routes. When you go to a new route you call .push() and when you want to go back or if someone hits the back button .pop() is called.

It's pretty simple. But the code to create one of these routes is not. Like look at this:

class TaskRoute extends StatefulWidget { TaskState createState() => TaskState(); } class TaskState extends State<taskroute> { ... }

Every single time we want to create a new route/widget class. Why do we need all this boilerplate? Why do we need Stateful/State/Stateless (not pictured). I think it's for optimization or something but it's still annoying.

So now I should probably talk about the language Dart. Oh, Dart. It's not a bad language. Not as bad as Javascript anyways. The best way to describe Dart is to say it's a modern COOL (C-like Object Oriented Language) similar to other COOL's like C# and Java. Emphasis on modern. So as languages mature there's a tendency of adding random syntactic 'sugar' that no one really needs or asked for that only serve to alienate newcomers to the language. Like take C++. C with classes, right? Nope. Now it's this giant behemoth of a language that takes ages to compile. And I've noticed the same thing with C#. In fact most of the newer syntactic sugar additions to C# are in Dart. Almost as if the Dart team is copying from C#. Hmm...

And this is a particular sore spot for Dart which has a million ways to do everything.

So take typing. There is static typing which means the compiler knows the types of everything at compile time and can alert you of any problems. Then there's hipster typing which means you're going to get a nasty surprise when you run that line of code you haven't tested yet. So which one do you expect Dart to choose? Trick question, Dart uses both. And different tutorials use one or the other. It can make it seem like a tutorial is written in a different language.

And it's not even like some dedicated keyword. This is the difference between static typing and hipster typing in Dart:

// Statically typed; will not compile var myVar = "Hi"; myVar = 5; // Hipster typed; will compile var myVar; myVar = "Hi"; myVar = 5;

Also: allocating new object. You can define new objects (oh, and by the way everything is a reference type in Dart) using the new keyword. But you don't have to use the keyword. It's completely optional. Which, why even have the keyword? Also it's possible to define a method that returns something without actually returning. I mean, you get a warning if you do that but it'll compile just fine. There's also a bunch of weird syntax like Dog({this.id, this.name, this.age}). This is basically the same as saying:

Dog(int id, String name, int age) { this.id = id; this.name = name; this.age = age; }

And there's a large amount of using functional map-like syntax instead of for loops. You know, the standard syntactic sugar stuff.

So syntactic sugar isn't in and of itself bad. The problem is when you have so much syntactic sugar it gives you syntactic diabetes meaning the language gets so inconsistent that it is difficult for new comers to learn. This is definitely a problem for Dart: one tutorial might use the new keyword and explicitly type all their variables. Then the next tutorial might not do any of that and it gets very confusing very fast.

But it's not all bad. There are a few neat things you can do in Dart. For one there's no public or private. To make something private by starting it with an _. It sort of reminds me of Python where you make a function by just indenting. I think it's pretty neat. Also you can have named constructors. It's pretty cool as you can name a constructor something like FromDatabase(Map<string dynamic>) if you just read from a database.

There's also two type of exceptions: error and exception. Error is bad, you should not be getting errors. Exceptions are, well, exceptions. So just catch them normally. I don't really know the difference between these two though. There are assert which is only called in debug builds. Oh, yeah, Flutter compiles to a debug build by default but there are also release and profiling builds.

Also when defining a list, which you'll do a lot in Flutter, every element can end in a comma, even the last one. This is something I've been thinking about whenever I code outside of an IDE. Adding a comma when there shouldn't be one results in a lot of compiler bugs (or in the case of hipster languages runtime bugs). So I think putting a comma after every item, even the last item is the way to go.

Lastly there is Future and async. A function signature that implements these is something like:

Future<list>> getTasks() async

and then you call it like:

tasks = await getTasks();

This is a major thing in Flutter. The main way I use it is when I push another route. I say something like await push() and that stops executing until the route being pushed calls pop(). And then I can do whatever management I need to make sure the data is saved.

Another way this comes into play is I can use an async method to load a database.

Although, to be honest, I sort of think this feature is a little superfluous. Especially in the database example. Reading from the database is so fast that stopping the whole app as the database returns its results is likely good enough. And the poping of pages could be done with a callback instead.

So how is it to actually develop for Flutter? Pretty good, actually. The first major feature of Flutter is the hot reload feature. Everytime you save your app it is instantly recompiled and sent to your phone (if it is already plugged in and the app is started) so the app updates faster than you can turn your head to look at it. It's pretty cool. It sure is a big shift from Unity's builds that can take minutes just to get an APK that you then have to install. Although it can fail sometimes. Usually when you rename something, but that rarely happens. I should probably mention here that I use my phone to test. You can also get a virtual device but that's like a 1GB download and I don't want to do that.

As for debugging instead of crashing flutter will give you a red screen of death.

Which, I mean, looks pretty ominous. Couldn't they have put a smily face on it or something like Windows?

There's also the call stacks when you get an error. They're not as compact as Unity and there's a lot of scrolling and they usually contain tons of information about Flutter's internal calls I don't care about before and after the relevant parts of the callstack. But I mean it's serviceable. Better than not having a callstack at all or a callstack that rarely points to the right thing like... some other languages.

Now there's Android Studio. It's basically a less good version of a JetBrains IDE. There's no telling you how many times something is called, there's no refactoring tools, it doesn't tell you to import packages to fix errors, it takes an extra click to get into the search all screen (Ctrl+N vs Ctrl+T), and it doesn't alert you if something isn't used. And it still takes more RAM than Chrome. Like, what are you doing? But at least it supports the Material theme I'm using on Rider. Like, it doesn't matter if the IDE sucks, as long as it looks good, right?

The only thing it really has over Rider (which I was using for Unity C#) is that it automatically inserts a comment telling you that this end brace corresponds to a particular widget. Which given the nested nature of build() method is quite useful. Not useful enough to get me to not jump ship to IntelliJ though.

So last but not least: the problems I have with Flutter. And there are a lot of them. The biggest one is the documentation. You know, for something made by Google that is almost 3 years old you'd think it would have better documentation. But no. You still see things like: "Enables the form to veto attempts by the user to dismiss the ModalRoute that contains the form." In all fairness this is the exception rather than the rule. Most of the commonly used widgets do have good documentation. But when you click to what a class is you still get this nonsense.

And there are a few bugs still. I encountered one where if you use Navigator.pop() it does not trigger the onPop callback. You need to use Navigator.maybePop() instead.

So all in all Flutter is a fine framework and pretty fun to program for. The foundation is pretty solid, it's just some of the documentation that is not quite up to snuff and some things can be hard to do due to not having the proper widget. Two problems that I'm sure will be solved soon. And once they are I think Flutter has a pretty good shot at being the most popular framework in the world due to its ability to run on Android, iOS, Web, Windows, Mac, Linux, and ChromeOS with an identical experience on all platforms.