Upload flutter_docs_portion.txt

flutter_docs_portion.txt

@@ -0,0 +1,948 @@
+<topic_start>
+flutter for android developers
+this document is meant for android developers looking to apply their
+existing android knowledge to build mobile apps with flutter.
+if you understand the fundamentals of the android framework then you
+can use this document as a jump start to flutter development.
+info note
+  to integrate flutter code into your android app, see
+  add flutter to existing app.
+your android knowledge and skill set are highly valuable when building with
+flutter, because flutter relies on the mobile operating system for numerous
+capabilities and configurations. flutter is a new way to build UIs for mobile,
+but it has a plugin system to communicate with android (and iOS) for non-UI
+tasks. if you’re an expert with android, you don’t have to relearn everything
+to use flutter.
+this document can be used as a cookbook by jumping around and
+finding questions that are most relevant to your needs.
+<topic_end>
+<topic_start>
+views
+<topic_end>
+<topic_start>
+what is the equivalent of a view in flutter?
+how is react-style, or declarative, programming different than the
+  traditional imperative style?
+  for a comparison, see introduction to declarative UI.
+in android, the view is the foundation of everything that shows up on the
+screen. buttons, toolbars, and inputs, everything is a view.
+in flutter, the rough equivalent to a view is a widget.
+widgets don’t map exactly to android views, but while you’re getting
+acquainted with how flutter works you can think of them as
+“the way you declare and construct UI”.
+however, these have a few differences to a view. to start, widgets have a
+different lifespan: they are immutable and only exist until they need to be
+changed. whenever widgets or their state change, flutter’s framework creates
+a new tree of widget instances. in comparison, an android view is drawn once
+and does not redraw until invalidate is called.
+flutter’s widgets are lightweight, in part due to their immutability.
+because they aren’t views themselves, and aren’t directly drawing anything,
+but rather are a description of the UI and its semantics that get “inflated”
+into actual view objects under the hood.
+flutter includes the material components library.
+these are widgets that implement the
+material design guidelines. material design is a
+flexible design system optimized for all platforms,
+including iOS.
+but flutter is flexible and expressive enough to implement any design language.
+for example, on iOS, you can use the cupertino widgets
+to produce an interface that looks like apple’s iOS design language.
+<topic_end>
+<topic_start>
+how do i update widgets?
+in android, you update your views by directly mutating them. however,
+in flutter, widgets are immutable and are not updated directly,
+instead you have to work with the widget’s state.
+this is where the concept of stateful and stateless widgets comes from.
+a StatelessWidget is just what it sounds like—a
+widget with no state information.
+StatelessWidgets are useful when the part of the user interface
+you are describing does not depend on anything other than the configuration
+information in the object.
+for example, in android, this is similar to placing an ImageView
+with your logo. the logo is not going to change during runtime,
+so use a StatelessWidget in flutter.
+if you want to dynamically change the UI based on data received
+after making an HTTP call or user interaction then you have to work
+with StatefulWidget and tell the flutter framework that the widget’s
+state has been updated so it can update that widget.
+the important thing to note here is at the core both stateless and stateful
+widgets behave the same. they rebuild every frame, the difference is the
+StatefulWidget has a state object that stores state data across frames
+and restores it.
+if you are in doubt, then always remember this rule: if a widget changes
+(because of user interactions, for example) it’s stateful.
+however, if a widget reacts to change, the containing parent widget can
+still be stateless if it doesn’t itself react to change.
+the following example shows how to use a StatelessWidget. a common
+StatelessWidget is the text widget. if you look at the implementation of
+the text widget you’ll find that it subclasses StatelessWidget.
+<code_start>
+text(
+  'i like flutter!',
+  style: TextStyle(fontWeight: FontWeight.bold),
+);
+<code_end>
+as you can see, the text widget has no state information associated with it,
+it renders what is passed in its constructors and nothing more.
+but, what if you want to make “i like flutter” change dynamically, for
+example when clicking a FloatingActionButton?
+to achieve this, wrap the text widget in a StatefulWidget and
+update it when the user clicks the button.
+for example:
+<code_start>
+import 'package:flutter/material.dart';
+void main() {
+  runApp(const SampleApp());
+}
+class SampleApp extends StatelessWidget {
+  const SampleApp({super.key});
+  // this widget is the root of your application.
+  @override
+  widget build(BuildContext context) {
+    return MaterialApp(
+      title: 'sample app',
+      theme: ThemeData(
+        colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
+      ),
+      home: const SampleAppPage(),
+    );
+  }
+}
+class SampleAppPage extends StatefulWidget {
+  const SampleAppPage({super.key});
+  @override
+  State<SampleAppPage> createState() => _SampleAppPageState();
+}
+class _SampleAppPageState extends State<SampleAppPage> {
+  // default placeholder text.
+  string textToShow = 'i like flutter';
+  void _updateText() {
+    setState(() {
+      // update the text.
+      textToShow = 'flutter is awesome!';
+    });
+  }
+  @override
+  widget build(BuildContext context) {
+    return scaffold(
+      appBar: AppBar(
+        title: const Text('Sample app'),
+      ),
+      body: center(child: Text(textToShow)),
+      floatingActionButton: FloatingActionButton(
+        onPressed: _updateText,
+        tooltip: 'update text',
+        child: const Icon(Icons.update),
+      ),
+    );
+  }
+}
+<code_end>
+<topic_end>
+<topic_start>
+how do i lay out my widgets? where is my XML layout file?
+in android, you write layouts in XML, but in flutter you write your layouts
+with a widget tree.
+the following example shows how to display a simple widget with padding:
+<code_start>
+@override
+widget build(BuildContext context) {
+  return scaffold(
+    appBar: AppBar(
+      title: const Text('Sample app'),
+    ),
+    body: center(
+      child: ElevatedButton(
+        style: ElevatedButton.styleFrom(
+          padding: const EdgeInsets.only(left: 20, right: 30),
+        ),
+        onPressed: () {},
+        child: const Text('Hello'),
+      ),
+    ),
+  );
+}
+<code_end>
+you can view some of the layouts that flutter has to offer in the
+widget catalog.
+<topic_end>
+<topic_start>
+how do i add or remove a component from my layout?
+in android, you call addChild() or removeChild()
+on a parent to dynamically add or remove child views.
+in flutter, because widgets are immutable there is
+no direct equivalent to addChild().  instead,
+you can pass a function to the parent that returns a widget,
+and control that child’s creation with a boolean flag.
+for example, here is how you can toggle between two
+widgets when you click on a FloatingActionButton:
+<code_start>
+import 'package:flutter/material.dart';
+void main() {
+  runApp(const SampleApp());
+}
+class SampleApp extends StatelessWidget {
+  const SampleApp({super.key});
+  // this widget is the root of your application.
+  @override
+  widget build(BuildContext context) {
+    return MaterialApp(
+      title: 'sample app',
+      theme: ThemeData(
+        colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
+      ),
+      home: const SampleAppPage(),
+    );
+  }
+}
+class SampleAppPage extends StatefulWidget {
+  const SampleAppPage({super.key});
+  @override
+  State<SampleAppPage> createState() => _SampleAppPageState();
+}
+class _SampleAppPageState extends State<SampleAppPage> {
+  // default value for toggle.
+  bool toggle = true;
+  void _toggle() {
+    setState(() {
+      toggle = !toggle;
+    });
+  }
+  widget _getToggleChild() {
+    if (toggle) {
+      return const Text('Toggle one');
+    } else {
+      return ElevatedButton(
+        onPressed: () {},
+        child: const Text('Toggle two'),
+      );
+    }
+  }
+  @override
+  widget build(BuildContext context) {
+    return scaffold(
+      appBar: AppBar(
+        title: const Text('Sample app'),
+      ),
+      body: center(
+        child: _getToggleChild(),
+      ),
+      floatingActionButton: FloatingActionButton(
+        onPressed: _toggle,
+        tooltip: 'update text',
+        child: const Icon(Icons.update),
+      ),
+    );
+  }
+}
+<code_end>
+<topic_end>
+<topic_start>
+how do i animate a widget?
+in android, you either create animations using XML, or call the animate()
+method on a view. in flutter, animate widgets using the animation
+library by wrapping widgets inside an animated widget.
+in flutter, use an AnimationController which is an animation<double>
+that can pause, seek, stop and reverse the animation. it requires a ticker
+that signals when vsync happens, and produces a linear interpolation between
+0 and 1 on each frame while it’s running. you then create one or more
+animations and attach them to the controller.
+for example, you might use CurvedAnimation to implement an animation
+along an interpolated curve. in this sense, the controller
+is the “master” source of the animation progress and the CurvedAnimation
+computes the curve that replaces the controller’s default linear motion.
+like widgets, animations in flutter work with composition.
+when building the widget tree you assign the animation to an animated
+property of a widget, such as the opacity of a FadeTransition, and tell the
+controller to start the animation.
+the following example shows how to write a FadeTransition that fades the
+widget into a logo when you press the FloatingActionButton:
+<code_start>
+import 'package:flutter/material.dart';
+void main() {
+  runApp(const FadeAppTest());
+}
+class FadeAppTest extends StatelessWidget {
+  const FadeAppTest({super.key});
+  // this widget is the root of your application.
+  @override
+  widget build(BuildContext context) {
+    return MaterialApp(
+      title: 'fade demo',
+      theme: ThemeData(
+        colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
+      ),
+      home: const MyFadeTest(title: 'fade demo'),
+    );
+  }
+}
+class MyFadeTest extends StatefulWidget {
+  const MyFadeTest({super.key, required this.title});
+  final string title;
+  @override
+  State<MyFadeTest> createState() => _MyFadeTest();
+}
+class _MyFadeTest extends State<MyFadeTest> with TickerProviderStateMixin {
+  late AnimationController controller;
+  late CurvedAnimation curve;
+  @override
+  void initState() {
+    super.initState();
+    controller = AnimationController(
+      duration: const duration(milliseconds: 2000),
+      vsync: this,
+    );
+    curve = CurvedAnimation(
+      parent: controller,
+      curve: Curves.easeIn,
+    );
+  }
+  @override
+  widget build(BuildContext context) {
+    return scaffold(
+      appBar: AppBar(
+        title: text(widget.title),
+      ),
+      body: center(
+        child: FadeTransition(
+          opacity: curve,
+          child: const FlutterLogo(
+            size: 100,
+          ),
+        ),
+      ),
+      floatingActionButton: FloatingActionButton(
+        tooltip: 'fade',
+        onPressed: () {
+          controller.forward();
+        },
+        child: const Icon(Icons.brush),
+      ),
+    );
+  }
+}
+<code_end>
+for more information, see
+animation & motion widgets,
+the animations tutorial,
+and the animations overview.
+<topic_end>
+<topic_start>
+how do i use a canvas to draw/paint?
+in android, you would use the canvas and drawable
+to draw images and shapes to the screen.
+flutter has a similar canvas API as well,
+since it’s based on the same low-level rendering engine, skia.
+as a result, painting to a canvas in flutter
+is a very familiar task for android developers.
+flutter has two classes that help you draw to the canvas: CustomPaint
+and CustomPainter,
+the latter of which implements your algorithm to draw to the canvas.
+to learn how to implement a signature painter in flutter,
+see collin’s answer on custom paint.
+<code_start>
+import 'package:flutter/material.dart';
+void main() => runApp(const MaterialApp(home: DemoApp()));
+class DemoApp extends StatelessWidget {
+  const DemoApp({super.key});
+  @override
+  widget build(BuildContext context) => const scaffold(body: signature());
+}
+class signature extends StatefulWidget {
+  const signature({super.key});
+  @override
+  SignatureState createState() => SignatureState();
+}
+class SignatureState extends State<Signature> {
+  List<Offset?> _points = <offset>[];
+  @override
+  widget build(BuildContext context) {
+    return GestureDetector(
+      onPanUpdate: (details) {
+        setState(() {
+          RenderBox? referenceBox = context.findRenderObject() as RenderBox;
+          offset localPosition =
+              referenceBox.globalToLocal(details.globalPosition);
+          _points = List.from(_points)..add(localPosition);
+        });
+      },
+      onPanEnd: (details) => _points.add(null),
+      child: CustomPaint(
+        painter: SignaturePainter(_points),
+        size: size.infinite,
+      ),
+    );
+  }
+}
+class SignaturePainter extends CustomPainter {
+  SignaturePainter(this.points);
+  final List<Offset?> points;
+  @override
+  void paint(Canvas canvas, size size) {
+    var paint = paint()
+      ..color = colors.black
+      ..strokeCap = StrokeCap.round
+      ..strokeWidth = 5;
+    for (int i = 0; i < points.length - 1; i++) {
+      if (points[i] != null && points[i + 1] != null) {
+        canvas.drawLine(points[i]!, points[i + 1]!, paint);
+      }
+    }
+  }
+  @override
+  bool shouldRepaint(SignaturePainter oldDelegate) =>
+      oldDelegate.points != points;
+}
+<code_end>
+<topic_end>
+<topic_start>
+how do i build custom widgets?
+in android, you typically subclass view, or use a pre-existing view,
+to override and implement methods that achieve the desired behavior.
+in flutter, build a custom widget by composing
+smaller widgets (instead of extending them).
+it is somewhat similar to implementing a custom ViewGroup
+in android, where all the building blocks are already existing,
+but you provide a different behavior—for example,
+custom layout logic.
+for example, how do you build a CustomButton that takes a label in
+the constructor? create a CustomButton that composes a ElevatedButton with
+a label, rather than by extending ElevatedButton:
+<code_start>
+class CustomButton extends StatelessWidget {
+  final string label;
+  const CustomButton(this.label, {super.key});
+  @override
+  widget build(BuildContext context) {
+    return ElevatedButton(
+      onPressed: () {},
+      child: text(label),
+    );
+  }
+}
+<code_end>
+then use CustomButton, just as you’d use any other flutter widget:
+<code_start>
+@override
+widget build(BuildContext context) {
+  return const center(
+    child: CustomButton('Hello'),
+  );
+}
+<code_end>
+<topic_end>
+<topic_start>
+intents
+<topic_end>
+<topic_start>
+what is the equivalent of an intent in flutter?
+in android, there are two main use cases for intents: navigating between
+activities, and communicating with components. flutter, on the other hand,
+does not have the concept of intents, although you can still start intents
+through native integrations (using a plugin).
+flutter doesn’t really have a direct equivalent to activities and fragments;
+rather, in flutter you navigate between screens, using a navigator and
+routes, all within the same activity.
+a route is an abstraction for a “screen” or “page” of an app, and a
+navigator is a widget that manages routes. a route roughly maps to an
+activity, but it does not carry the same meaning. a navigator can push
+and pop routes to move from screen to screen. navigators work like a stack
+on which you can push() new routes you want to navigate to, and from
+which you can pop() routes when you want to “go back”.
+in android, you declare your activities inside the app’s AndroidManifest.xml.
+in flutter, you have a couple options to navigate between pages:
+the following example builds a map.
+<code_start>
+void main() {
+  runApp(MaterialApp(
+    home: const MyAppHome(), // becomes the route named '/'.
+    routes: <string, WidgetBuilder>{
+      '/a': (context) => const MyPage(title: 'page a'),
+      '/b': (context) => const MyPage(title: 'page b'),
+      '/c': (context) => const MyPage(title: 'page c'),
+    },
+  ));
+}
+<code_end>
+navigate to a route by pushing its name to the navigator.
+<code_start>
+Navigator.of(context).pushNamed('/b');
+<code_end>
+the other popular use-case for intents is to call external components such
+as a camera or file picker. for this, you would need to create a native platform
+integration (or use an existing plugin).
+to learn how to build a native platform integration,
+see developing packages and plugins.
+<topic_end>
+<topic_start>
+how do i handle incoming intents from external applications in flutter?
+flutter can handle incoming intents from android by directly talking to the
+android layer and requesting the data that was shared.
+the following example registers a text share intent filter on the native
+activity that runs our flutter code, so other apps can share text with
+our flutter app.
+the basic flow implies that we first handle the shared text data on the
+android native side (in our activity), and then wait until flutter requests
+for the data to provide it using a MethodChannel.
+first, register the intent filter for all intents in AndroidManifest.xml:
+then in MainActivity, handle the intent, extract the text that was
+shared from the intent, and hold onto it. when flutter is ready to process,
+it requests the data using a platform channel, and it’s sent
+across from the native side:
+finally, request the data from the flutter side
+when the widget is rendered:
+<code_start>
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+void main() {
+  runApp(const SampleApp());
+}
+class SampleApp extends StatelessWidget {
+  const SampleApp({super.key});
+  // this widget is the root of your application.
+  @override
+  widget build(BuildContext context) {
+    return MaterialApp(
+      title: 'sample shared app handler',
+      theme: ThemeData(
+        colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
+      ),
+      home: const SampleAppPage(),
+    );
+  }
+}
+class SampleAppPage extends StatefulWidget {
+  const SampleAppPage({super.key});
+  @override
+  State<SampleAppPage> createState() => _SampleAppPageState();
+}
+class _SampleAppPageState extends State<SampleAppPage> {
+  static const platform = MethodChannel('app.channel.shared.data');
+  string dataShared = 'no data';
+  @override
+  void initState() {
+    super.initState();
+    getSharedText();
+  }
+  @override
+  widget build(BuildContext context) {
+    return scaffold(body: center(child: Text(dataShared)));
+  }
+  future<void> getSharedText() async {
+    var sharedData = await platform.invokeMethod('getSharedText');
+    if (shareddata != null) {
+      setState(() {
+        dataShared = sharedData;
+      });
+    }
+  }
+}
+<code_end>
+<topic_end>
+<topic_start>
+what is the equivalent of startActivityForResult()?
+the navigator class handles routing in flutter and is used to get
+a result back from a route that you have pushed on the stack.
+this is done by awaiting on the future returned by push().
+for example, to start a location route that lets the user select
+their location, you could do the following:
+<code_start>
+object? coordinates = await Navigator.of(context).pushNamed('/location');
+<code_end>
+and then, inside your location route, once the user has selected their location
+you can pop the stack with the result:
+<code_start>
+navigator.of(context).pop({'lat': 43.821757, 'long': -79.226392});
+<code_end>
+<topic_end>
+<topic_start>
+async UI
+<topic_end>
+<topic_start>
+what is the equivalent of runOnUiThread() in flutter?
+dart has a single-threaded execution model, with support for isolates
+(a way to run dart code on another thread), an event loop, and
+asynchronous programming. unless you spawn an isolate, your dart code
+runs in the main UI thread and is driven by an event loop. flutter’s event
+loop is equivalent to android’s main looper—that is, the looper that
+is attached to the main thread.
+dart’s single-threaded model doesn’t mean you need to run everything as a
+blocking operation that causes the UI to freeze. unlike android, which
+requires you to keep the main thread free at all times, in flutter,
+use the asynchronous facilities that the dart language provides, such as
+async/await, to perform asynchronous work. you might be familiar with
+the async/await paradigm if you’ve used it in c#, javascript, or if you
+have used kotlin’s coroutines.
+for example, you can run network code without causing the UI to hang by
+using async/await and letting dart do the heavy lifting:
+<code_start>
+future<void> loadData() async {
+  var dataURL = uri.parse('https://jsonplaceholder.typicode.com/posts');
+  http.Response response = await http.get(dataURL);
+  setState(() {
+    widgets = jsonDecode(response.body);
+  });
+}
+<code_end>
+once the awaited network call is done, update the UI by calling setState(),
+which triggers a rebuild of the widget subtree and updates the data.
+the following example loads data asynchronously and displays it in a ListView:
+<code_start>
+import 'dart:convert';
+import 'package:flutter/material.dart';
+import 'package:http/http.dart' as http;
+void main() {
+  runApp(const SampleApp());
+}
+class SampleApp extends StatelessWidget {
+  const SampleApp({super.key});
+  @override
+  widget build(BuildContext context) {
+    return MaterialApp(
+      title: 'sample app',
+      theme: ThemeData(
+        colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
+      ),
+      home: const SampleAppPage(),
+    );
+  }
+}
+class SampleAppPage extends StatefulWidget {
+  const SampleAppPage({super.key});
+  @override
+  State<SampleAppPage> createState() => _SampleAppPageState();
+}
+class _SampleAppPageState extends State<SampleAppPage> {
+  list widgets = [];
+  @override
+  void initState() {
+    super.initState();
+    loadData();
+  }
+  @override
+  widget build(BuildContext context) {
+    return scaffold(
+      appBar: AppBar(
+        title: const Text('Sample app'),
+      ),
+      body: ListView.builder(
+        itemCount: widgets.length,
+        itemBuilder: (context, position) {
+          return getRow(position);
+        },
+      ),
+    );
+  }
+  widget getRow(int i) {
+    return padding(
+      padding: const EdgeInsets.all(10),
+      child: Text("Row ${widgets[i]["title"]}"),
+    );
+  }
+  future<void> loadData() async {
+    var dataURL = uri.parse('https://jsonplaceholder.typicode.com/posts');
+    http.Response response = await http.get(dataURL);
+    setState(() {
+      widgets = jsonDecode(response.body);
+    });
+  }
+}
+<code_end>
+refer to the next section for more information on doing work in the
+background, and how flutter differs from android.
+<topic_end>
+<topic_start>
+how do you move work to a background thread?
+in android, when you want to access a network resource you would typically
+move to a background thread and do the work, as to not block the main thread,
+and avoid ANRs. for example, you might be using an AsyncTask, a LiveData,
+an IntentService, a JobScheduler job, or an RxJava pipeline with a
+scheduler that works on background threads.
+since flutter is single threaded and runs an event loop (like node.js), you
+don’t have to worry about thread management or spawning background threads. if
+you’re doing I/O-bound work, such as disk access or a network call, then
+you can safely use async/await and you’re all set. if, on the other
+hand, you need to do computationally intensive work that keeps the CPU busy,
+you want to move it to an isolate to avoid blocking the event loop, like
+you would keep any sort of work out of the main thread in android.
+for I/O-bound work, declare the function as an async function,
+and await on long-running tasks inside the function:
+<code_start>
+future<void> loadData() async {
+  var dataURL = uri.parse('https://jsonplaceholder.typicode.com/posts');
+  http.Response response = await http.get(dataURL);
+  setState(() {
+    widgets = jsonDecode(response.body);
+  });
+}
+<code_end>
+this is how you would typically do network or database calls, which are both
+I/O operations.
+on android, when you extend AsyncTask, you typically override 3 methods,
+onPreExecute(), doInBackground() and onPostExecute(). there is no
+equivalent in flutter, since you await on a long-running function, and
+dart’s event loop takes care of the rest.
+however, there are times when you might be processing a large amount of data and
+your UI hangs. in flutter, use isolates to take advantage of
+multiple CPU cores to do long-running or computationally intensive tasks.
+isolates are separate execution threads that do not share any memory
+with the main execution memory heap. this means you can’t access variables from
+the main thread, or update your UI by calling setState().
+unlike android threads,
+isolates are true to their name, and cannot share memory
+(in the form of static fields, for example).
+the following example shows, in a simple isolate, how to share data back to
+the main thread to update the UI.
+<code_start>
+future<void> loadData() async {
+  ReceivePort receivePort = ReceivePort();
+  await Isolate.spawn(dataLoader, receivePort.sendPort);
+  // the 'echo' isolate sends its SendPort as the first message.
+  SendPort sendPort = await receivePort.first;
+  list msg = await sendReceive(
+    sendPort,
+    'https://jsonplaceholder.typicode.com/posts',
+  );
+  setState(() {
+    widgets = msg;
+  });
+}
+// the entry point for the isolate.
+static future<void> dataLoader(SendPort sendPort) async {
+  // open the ReceivePort for incoming messages.
+  ReceivePort port = ReceivePort();
+  // notify any other isolates what port this isolate listens to.
+  sendPort.send(port.sendPort);
+  await for (var msg in port) {
+    string data = msg[0];
+    SendPort replyTo = msg[1];
+    string dataURL = data;
+    http.Response response = await http.get(Uri.parse(dataURL));
+    // lots of JSON to parse
+    replyTo.send(jsonDecode(response.body));
+  }
+}
+future sendReceive(SendPort port, msg) {
+  ReceivePort response = ReceivePort();
+  port.send([msg, response.sendPort]);
+  return response.first;
+}
+<code_end>
+here, dataLoader() is the isolate that runs in its own separate
+execution thread.  in the isolate you can perform more CPU intensive
+processing (parsing a big JSON, for example),
+or perform computationally intensive math,
+such as encryption or signal processing.
+you can run the full example below:
+<code_start>
+import 'dart:async';
+import 'dart:convert';
+import 'dart:isolate';
+import 'package:flutter/material.dart';
+import 'package:http/http.dart' as http;
+void main() {
+  runApp(const SampleApp());
+}
+class SampleApp extends StatelessWidget {
+  const SampleApp({super.key});
+  @override
+  widget build(BuildContext context) {
+    return MaterialApp(
+      title: 'sample app',
+      theme: ThemeData(
+        colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
+      ),
+      home: const SampleAppPage(),
+    );
+  }
+}
+class SampleAppPage extends StatefulWidget {
+  const SampleAppPage({super.key});
+  @override
+  State<SampleAppPage> createState() => _SampleAppPageState();
+}
+class _SampleAppPageState extends State<SampleAppPage> {
+  list widgets = [];
+  @override
+  void initState() {
+    super.initState();
+    loadData();
+  }
+  widget getBody() {
+    bool showLoadingDialog = widgets.isEmpty;
+    if (showloadingdialog) {
+      return getProgressDialog();
+    } else {
+      return getListView();
+    }
+  }
+  widget getProgressDialog() {
+    return const center(child: CircularProgressIndicator());
+  }
+  @override
+  widget build(BuildContext context) {
+    return scaffold(
+      appBar: AppBar(
+        title: const Text('Sample app'),
+      ),
+      body: getBody(),
+    );
+  }
+  ListView getListView() {
+    return ListView.builder(
+      itemCount: widgets.length,
+      itemBuilder: (context, position) {
+        return getRow(position);
+      },
+    );
+  }
+  widget getRow(int i) {
+    return padding(
+      padding: const EdgeInsets.all(10),
+      child: Text("Row ${widgets[i]["title"]}"),
+    );
+  }
+  future<void> loadData() async {
+    ReceivePort receivePort = ReceivePort();
+    await Isolate.spawn(dataLoader, receivePort.sendPort);
+    // the 'echo' isolate sends its SendPort as the first message.
+    SendPort sendPort = await receivePort.first;
+    list msg = await sendReceive(
+      sendPort,
+      'https://jsonplaceholder.typicode.com/posts',
+    );
+    setState(() {
+      widgets = msg;
+    });
+  }
+  // the entry point for the isolate.
+  static future<void> dataLoader(SendPort sendPort) async {
+    // open the ReceivePort for incoming messages.
+    ReceivePort port = ReceivePort();
+    // notify any other isolates what port this isolate listens to.
+    sendPort.send(port.sendPort);
+    await for (var msg in port) {
+      string data = msg[0];
+      SendPort replyTo = msg[1];
+      string dataURL = data;
+      http.Response response = await http.get(Uri.parse(dataURL));
+      // lots of JSON to parse
+      replyTo.send(jsonDecode(response.body));
+    }
+  }
+  future sendReceive(SendPort port, msg) {
+    ReceivePort response = ReceivePort();
+    port.send([msg, response.sendPort]);
+    return response.first;
+  }
+}
+<code_end>
+<topic_end>
+<topic_start>
+what is the equivalent of OkHttp on flutter?
+making a network call in flutter is easy when you use the
+popular http package.
+while the http package doesn’t have every feature found in OkHttp,
+it abstracts away much of the networking that you would normally implement
+yourself, making it a simple way to make network calls.
+to add the http package as a dependency, run flutter pub add:
+to make a network call, call await on the async function http.get():
+<code_start>
+import 'dart:developer' as developer;
+import 'package:http/http.dart' as http;
+future<void> loadData() async {
+  var dataURL = uri.parse('https://jsonplaceholder.typicode.com/posts');
+  http.Response response = await http.get(dataURL);
+  developer.log(response.body);
+}
+<code_end>
+<topic_end>
+<topic_start>
+how do i show the progress for a long-running task?
+in android you would typically show a ProgressBar view in your UI while
+executing a long-running task on a background thread.
+in flutter, use a ProgressIndicator widget.
+show the progress programmatically by controlling when it’s rendered
+through a boolean flag. tell flutter to update its state before your
+long-running task starts, and hide it after it ends.
+in the following example, the build function is separated into three different
+functions. if showLoadingDialog is true (when widgets.isEmpty),
+then render the ProgressIndicator. otherwise, render the
+ListView with the data returned from a network call.
+<code_start>
+import 'dart:convert';
+import 'package:flutter/material.dart';
+import 'package:http/http.dart' as http;
+void main() {
+  runApp(const SampleApp());
+}
+class SampleApp extends StatelessWidget {
+  const SampleApp({super.key});
+  @override
+  widget build(BuildContext context) {
+    return MaterialApp(
+      title: 'sample app',
+      theme: ThemeData(
+        colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
+      ),
+      home: const SampleAppPage(),
+    );
+  }
+}
+class SampleAppPage extends StatefulWidget {
+  const SampleAppPage({super.key});
+  @override
+  State<SampleAppPage> createState() => _SampleAppPageState();
+}
+class _SampleAppPageState extends State<SampleAppPage> {
+  list widgets = [];
+  @override
+  void initState() {
+    super.initState();
+    loadData();
+  }
+  widget getBody() {
+    bool showLoadingDialog = widgets.isEmpty;
+    if (showloadingdialog) {
+      return getProgressDialog();
+    } else {
+      return getListView();
+    }
+  }
+  widget getProgressDialog() {
+    return const center(child: CircularProgressIndicator());
+  }
+  @override
+  widget build(BuildContext context) {
+    return scaffold(
+      appBar: AppBar(
+        title: const Text('Sample app'),
+      ),
+      body: getBody(),
+    );
+  }
+  ListView getListView() {
+    return ListView.builder(
+      itemCount: widgets.length,
+      itemBuilder: (context, position) {
+        return getRow(position);
+      },
+    );
+  }
+  widget getRow(int i) {
+    return padding(
+      padding: const EdgeInsets.all(10),
+      child: Text("Row ${widgets[i]["title"]}"),
+    );
+  }
+  future<void> loadData() async {
+    var dataURL = uri.parse('https://jsonplaceholder.typicode.com/posts');
+    http.Response response = await http.get(dataURL);
+    setState(() {
+      widgets = jsonDecode(response.body);
+    });
+  }
+}
+<code_end>
+<topic_end>