Flutter - free resource mobile app, desktop, web

Home All post

Flutter’s built-in CircularProgressIndicator is fine until a designer hands you a ring that starts at four o’clock, stops at eight, and wraps a button. At that point you stop configuring a widget and start drawing one. This walkthrough builds that ring from scratch with CustomPaint, and — more usefully — explains the angle maths that trips most people up the first time.

This assumes you are comfortable with basic Flutter widgets. The focus here is the painting, not the scaffolding.

The three widgets involved

Only three do the real work:

Container — draws the static outer circle (the “track” the progress sits on).
Stack — lets the painted arc overlap that circle instead of sitting next to it.
CustomPaint — hands you a Canvas so you can draw the arc yourself.

Start with the track

Before any painting, get a plain circle on screen. A Container with BoxShape.circle and a border is enough, and wrapping it in a Stack now saves a refactor in a minute.

import 'package:flutter/material.dart';

const Color darkBlue = Color.fromARGB(255, 18, 32, 47);

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      theme: ThemeData.dark().copyWith(scaffoldBackgroundColor: darkBlue),
      debugShowCheckedModeBanner: false,
      home: const Scaffold(
        body: Center(
          child: ProgressIndicatorButton(),
        ),
      ),
    );
  }
}

class ProgressIndicatorButton extends StatelessWidget {
  const ProgressIndicatorButton({
    Key? key,
  }) : super(key: key);

  @override
  Widget build(BuildContext context) {
    const buttonSize = 80.0;
    const borderWidth = 2.0;

    return Stack(
      children: [
        Container(
          width: buttonSize,
          height: buttonSize,
          decoration: BoxDecoration(
            shape: BoxShape.circle,
            border: Border.all(
              color: Colors.white,
              width: borderWidth,
            ),
          ),
        ),
      ],
    );
  }
}

That gives you a thin white circle in the middle of a dark screen. Everything from here is painted on top of it.

Writing the CustomPainter

A CustomPaint widget is only as interesting as the CustomPainter you give it. A painter needs three things:

extend CustomPainter
implement paint
implement shouldRepaint

shouldRepaint does exactly what it sounds like: return true when a new instance of the painter should trigger a repaint. For a static indicator nothing changes between builds, so false is correct — and cheaper. (Return true, or compare fields against oldDelegate, once you start animating the sweep.)

Breaking down the paint method

paint receives the Canvas you draw on and the Size it was given. The canvas can draw rectangles, circles, lines and arbitrary paths; here we only want an arc.

void paint(Canvas canvas, Size size) {
    // 2
    final paint = Paint()
      // 3
      ..color = Colors.blue
      // 4
      ..strokeCap = StrokeCap.butt
      // 5
      ..style = PaintingStyle.stroke
      // 6
      ..strokeWidth = width;

    // 7
    final center = Offset(size.width / 2, size.height / 2);

    // 8
    final radius = (size.width / 2) - (width / 2);

    // 1
    canvas.drawArc(
      Rect.fromCircle(center: center, radius: radius),
      startAngle,
      sweepAngle,
      false,
      paint,
    );
  }

Line by line:

drawArc takes five arguments. The first is the Rect the arc is inscribed in — Rect.fromCircle keeps it perfectly round. The second is where the arc starts, the third how far it sweeps. The fourth (useCenter) decides whether the ends connect back to the centre; leave it false unless you want a pie slice. The fifth is the Paint.
Paint carries every visual property of the stroke and gets passed into drawArc.
color — the stroke colour.
strokeCap — how the two ends of the arc are finished. StrokeCap.butt cuts them flat; StrokeCap.round gives you the rounded caps most designs want.
style — PaintingStyle.fill floods the shape, PaintingStyle.stroke outlines it. A progress ring is an outline.
strokeWidth — the thickness of that outline. Pairs with PaintingStyle.stroke.
center — half the width and half the height, so the arc is centred in whatever box the painter was handed.
radius — half the width minus half the stroke width. Skip that subtraction and the stroke straddles the edge of the box and gets clipped.

Here is the whole file with the painter wired in, with the angle work still commented out so it compiles and runs:

import 'package:flutter/material.dart';
// import 'dart:math' as math;

const Color darkBlue = Color.fromARGB(255, 18, 32, 47);

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      theme: ThemeData.dark().copyWith(scaffoldBackgroundColor: darkBlue),
      debugShowCheckedModeBanner: false,
      home: const Scaffold(
        body: Center(
          child: ProgressIndicatorButton(),
        ),
      ),
    );
  }
}

class ProgressIndicatorButton extends StatelessWidget {
  const ProgressIndicatorButton({
    Key? key,
//     required this.startAngle,
//     required this.endAngle,
  }) : super(key: key);

//   final double startAngle;
//   final double endAngle;

  @override
  Widget build(BuildContext context) {
    const buttonSize = 80.0;
    const borderWidth = 2.0;

    return Stack(
      children: [
        Container(
          width: buttonSize,
          height: buttonSize,
          decoration: BoxDecoration(
            shape: BoxShape.circle,
            border: Border.all(
              color: Colors.white,
              width: borderWidth,
            ),
          ),
        ),
        SizedBox(
          width: buttonSize,
          height: buttonSize,
          child: CustomPaint(
            painter: ProgressIndicatorPainter(
              width: borderWidth,
//               startAngle: startAngle,
//               sweepAngle: endAngle,
            ),
            child: Center(
              child: Container(
                width: buttonSize - 20.0,
                height: buttonSize - 20.0,
                decoration: const BoxDecoration(
                  color: Colors.blue,
                  shape: BoxShape.circle,
                ),
                child: const Center(
                  child: Icon(
                    Icons.done,
                    size: 30.0,
                  ),
                ),
              ),
            ),
          ),
        ),
      ],
    );
  }
}

class ProgressIndicatorPainter extends CustomPainter {
  const ProgressIndicatorPainter({
    required this.width,
//     required this.startAngle,
//     required this.sweepAngle,
  }) : super();

  final double width;
//   final double startAngle;
//   final double sweepAngle;

  @override
  void paint(Canvas canvas, Size size) {
    final paint = Paint()
      ..color = Colors.blue
      ..strokeCap = StrokeCap.butt
      ..style = PaintingStyle.stroke
      ..strokeWidth = width;

    final center = Offset(size.width / 2, size.height / 2);
    final radius = (size.width / 2) - (width / 2);

//     canvas.drawArc(
//       Rect.fromCircle(center: center, radius: radius),
//       startAngle,
//       sweepAngle,
//       false,
//       paint,
//     );
  }

  @override
  bool shouldRepaint(CustomPainter oldDelegate) => false;
}

Keep those comments exactly where they are — uncommenting half of them will not compile.

What startAngle and sweepAngle actually mean

This is the part worth slowing down for.

startAngle is measured in radians and starts at 0 — the three o’clock position on the unit circle. The catch is direction: drawArc sweeps clockwise, while the unit circle you remember from school runs counter-clockwise. Rather than re-deriving everything, the shortcut is to read the position off the unit circle as usual and then negate it. Want the arc to begin at π/2 (twelve o’clock)? Pass -π/2.

sweepAngle is not an end position — it is a length. Whatever you pass is added to startAngle, and that sum is where the arc stops. To draw from π/2 round to 0, you need startAngle: -π/2 and sweepAngle: π/2, because −π/2 + π/2 = 0.

Working out the sweep for an arbitrary arc

Take the ring from the top of this post: it starts around 2π/3 and ends around 11π/6 on the unit circle. There is no clean subtraction that always gives you the sweep for a custom start, so count the arc in slices instead:

quadrant I is covered in full → π/2
quadrants II and IV contribute one π/6 slice each → π/6 + π/6

π/6 + π/6 + π/2 = 5π/6, and that is the sweep. The full code:

import 'package:flutter/material.dart';
import 'dart:math' as math;

const Color darkBlue = Color.fromARGB(255, 18, 32, 47);

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      theme: ThemeData.dark().copyWith(scaffoldBackgroundColor: darkBlue),
      debugShowCheckedModeBanner: false,
      home: const Scaffold(
        body: Center(
          child: ProgressIndicatorButton(
            startAngle: -2 * math.pi / 3,
            endAngle: 5 * math.pi / 6,
          ),
        ),
      ),
    );
  }
}

class ProgressIndicatorButton extends StatelessWidget {
  const ProgressIndicatorButton({
    Key? key,
    required this.startAngle,
    required this.endAngle,
  }) : super(key: key);

  final double startAngle;
  final double endAngle;

  @override
  Widget build(BuildContext context) {
    const buttonSize = 80.0;
    const borderWidth = 2.0;

    return Stack(
      children: [
        Container(
          width: buttonSize,
          height: buttonSize,
          decoration: BoxDecoration(
            shape: BoxShape.circle,
            border: Border.all(
              color: Colors.white,
              width: borderWidth,
            ),
          ),
        ),
        SizedBox(
          width: buttonSize,
          height: buttonSize,
          child: CustomPaint(
            painter: ProgressIndicatorPainter(
              width: borderWidth,
              startAngle: startAngle,
              sweepAngle: endAngle,
            ),
            child: Center(
              child: Container(
                width: buttonSize - 20.0,
                height: buttonSize - 20.0,
                decoration: const BoxDecoration(
                  color: Colors.blue,
                  shape: BoxShape.circle,
                ),
                child: const Center(
                  child: Icon(
                    Icons.done,
                    size: 30.0,
                  ),
                ),
              ),
            ),
          ),
        ),
      ],
    );
  }
}

class ProgressIndicatorPainter extends CustomPainter {
  const ProgressIndicatorPainter({
    required this.width,
    required this.startAngle,
    required this.sweepAngle,
  }) : super();

  final double width;
  final double startAngle;
  final double sweepAngle;

  @override
  void paint(Canvas canvas, Size size) {
    final paint = Paint()
      ..color = Colors.blue
      ..strokeCap = StrokeCap.butt
      ..style = PaintingStyle.stroke
      ..strokeWidth = width;

    final center = Offset(size.width / 2, size.height / 2);
    final radius = (size.width / 2) - (width / 2);

    canvas.drawArc(
      Rect.fromCircle(center: center, radius: radius),
      startAngle,
      sweepAngle,
      false,
      paint,
    );
  }

  @override
  bool shouldRepaint(CustomPainter oldDelegate) => false;
}

Prefer degrees? Convert at the edge

If radians make the calling code unreadable, take degrees into the painter and convert them right before drawArc. Nothing else changes — same concepts, friendlier numbers.

import 'package:flutter/material.dart';
import 'dart:math' as math;

const Color darkBlue = Color.fromARGB(255, 18, 32, 47);

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      theme: ThemeData.dark().copyWith(scaffoldBackgroundColor: darkBlue),
      debugShowCheckedModeBanner: false,
      home: const Scaffold(
        body: Center(
          child: ProgressIndicatorButton(
            startAngle: -120,
            endAngle: 150,
          ),
        ),
      ),
    );
  }
}

class ProgressIndicatorButton extends StatelessWidget {
  const ProgressIndicatorButton({
    Key? key,
    required this.startAngle,
    required this.endAngle,
  }) : super(key: key);

  final int startAngle;
  final int endAngle;

  @override
  Widget build(BuildContext context) {
    const buttonSize = 80.0;
    const borderWidth = 2.0;

    return Stack(
      children: [
        Container(
          width: buttonSize,
          height: buttonSize,
          decoration: BoxDecoration(
            shape: BoxShape.circle,
            border: Border.all(
              color: Colors.white,
              width: borderWidth,
            ),
          ),
        ),
        SizedBox(
          width: buttonSize,
          height: buttonSize,
          child: CustomPaint(
            painter: ProgressIndicatorPainter(
              width: borderWidth,
              startAngle: startAngle,
              sweepAngle: endAngle,
            ),
            child: Center(
              child: Container(
                width: buttonSize - 20.0,
                height: buttonSize - 20.0,
                decoration: const BoxDecoration(
                  color: Colors.blue,
                  shape: BoxShape.circle,
                ),
                child: const Center(
                  child: Icon(
                    Icons.done,
                    size: 30.0,
                  ),
                ),
              ),
            ),
          ),
        ),
      ],
    );
  }
}

class ProgressIndicatorPainter extends CustomPainter {
  const ProgressIndicatorPainter({
    required this.width,
    required this.startAngle,
    required this.sweepAngle,
  }) : super();

  final double width;
  final int startAngle;
  final int sweepAngle;

  @override
  void paint(Canvas canvas, Size size) {
    final paint = Paint()
      ..color = Colors.blue
      ..strokeCap = StrokeCap.butt
      ..style = PaintingStyle.stroke
      ..strokeWidth = width;

    final startAngleRad = startAngle * (math.pi / 180.0);
    final sweepAngleRad = sweepAngle * (math.pi / 180.0);

    final center = Offset(size.width / 2, size.height / 2);
    final radius = (size.width / 2) - (width / 2);

    canvas.drawArc(
      Rect.fromCircle(center: center, radius: radius),
      startAngleRad,
      sweepAngleRad,
      false,
      paint,
    );
  }

  @override
  bool shouldRepaint(CustomPainter oldDelegate) => false;
}

Two more to practise on

Same procedure, different numbers:

Starting at three o’clock. startAngle is 0 (or 0.0 in code). The sweep covers all of quadrant IV plus a π/6 slice of quadrant III: π/6 + π/2 = 4π/6.
Starting at −5π/4. In quadrant II you take the full quadrant, then in quadrant III a π/6 slice and a π/12 slice: π/2 + π/6 + π/12 = 3π/4.

Wrapping up

Counting slices per quadrant is not the most elegant way to derive a sweep angle, but it is reliable and you can do it on paper next to the design. Once the static ring is right, animating it is a small step: drive sweepAngle from an AnimationController, and flip shouldRepaint to compare against oldDelegate so Flutter actually redraws.

Originally published on FlutterCook. Read the latest version there — that copy is the one kept up to date.

CircularProgressIndicator có sẵn của Flutter dùng ổn — cho tới khi designer đưa bạn một vòng cung bắt đầu ở vị trí 4 giờ, kết thúc ở 8 giờ và ôm lấy một cái nút. Lúc đó bạn không còn cấu hình widget nữa mà phải tự vẽ nó. Bài này dựng vòng cung đó từ đầu bằng CustomPaint, và quan trọng hơn là giải thích phần tính góc — chỗ hầu hết mọi người vấp lần đầu.

Bài viết giả định bạn đã quen với widget cơ bản của Flutter. Trọng tâm ở đây là phần vẽ, không phải phần dựng khung.

Chỉ ba widget làm việc thật sự:

Container — vẽ vòng tròn viền tĩnh bên ngoài (đường “ray” mà tiến trình chạy trên đó).
Stack — cho phép cung vẽ chồng lên vòng tròn đó thay vì nằm cạnh.
CustomPaint — đưa cho bạn một Canvas để tự vẽ cung.

Bắt đầu với vòng tròn nền

Trước khi vẽ gì, hãy đưa một vòng tròn đơn giản lên màn hình. Một Container với BoxShape.circle và viền là đủ; bọc sẵn trong Stack ngay từ giờ sẽ đỡ phải sửa lại ở bước sau.

import 'package:flutter/material.dart';

const Color darkBlue = Color.fromARGB(255, 18, 32, 47);

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      theme: ThemeData.dark().copyWith(scaffoldBackgroundColor: darkBlue),
      debugShowCheckedModeBanner: false,
      home: const Scaffold(
        body: Center(
          child: ProgressIndicatorButton(),
        ),
      ),
    );
  }
}

class ProgressIndicatorButton extends StatelessWidget {
  const ProgressIndicatorButton({
    Key? key,
  }) : super(key: key);

  @override
  Widget build(BuildContext context) {
    const buttonSize = 80.0;
    const borderWidth = 2.0;

    return Stack(
      children: [
        Container(
          width: buttonSize,
          height: buttonSize,
          decoration: BoxDecoration(
            shape: BoxShape.circle,
            border: Border.all(
              color: Colors.white,
              width: borderWidth,
            ),
          ),
        ),
      ],
    );
  }
}

Kết quả là một vòng tròn viền trắng mảnh giữa nền tối. Mọi thứ từ đây trở đi được vẽ đè lên nó.

Viết CustomPainter

Widget CustomPaint chỉ hay ho bằng đúng cái CustomPainter bạn đưa cho nó. Một painter cần ba thứ:

kế thừa CustomPainter
cài đặt paint
cài đặt shouldRepaint

shouldRepaint đúng như tên gọi: trả về true khi một instance mới của painter cần vẽ lại. Với chỉ báo tĩnh thì không có gì thay đổi giữa các lần build, nên false là đúng — và rẻ hơn. (Khi bắt đầu animation cho cung, hãy trả true hoặc so sánh các trường với oldDelegate.)

Mổ xẻ phương thức paint

paint nhận Canvas để vẽ và Size mà nó được cấp. Canvas vẽ được hình chữ nhật, hình tròn, đường thẳng và cả path tùy ý; ở đây ta chỉ cần một cung (arc).

void paint(Canvas canvas, Size size) {
    // 2
    final paint = Paint()
      // 3
      ..color = Colors.blue
      // 4
      ..strokeCap = StrokeCap.butt
      // 5
      ..style = PaintingStyle.stroke
      // 6
      ..strokeWidth = width;

    // 7
    final center = Offset(size.width / 2, size.height / 2);

    // 8
    final radius = (size.width / 2) - (width / 2);

    // 1
    canvas.drawArc(
      Rect.fromCircle(center: center, radius: radius),
      startAngle,
      sweepAngle,
      false,
      paint,
    );
  }

Giải thích từng điểm:

drawArc nhận năm đối số. Thứ nhất là Rect chứa cung — Rect.fromCircle giữ cho nó tròn đều. Thứ hai là nơi cung bắt đầu, thứ ba là độ dài cung quét. Thứ tư (useCenter) quyết định hai đầu cung có nối về tâm hay không; để false trừ khi bạn muốn một miếng bánh. Thứ năm là Paint.
Paint giữ toàn bộ thuộc tính hiển thị của nét vẽ và được truyền vào drawArc.
color — màu nét vẽ.
strokeCap — kiểu bo hai đầu cung. StrokeCap.butt cắt phẳng; StrokeCap.round bo tròn, đây là kiểu đa số thiết kế cần.
style — PaintingStyle.fill tô đặc, PaintingStyle.stroke chỉ vẽ viền. Vòng tiến trình là viền.
strokeWidth — độ dày viền đó, đi kèm với PaintingStyle.stroke.
center — một nửa chiều rộng và một nửa chiều cao, để cung nằm giữa khung mà painter nhận được.
radius — nửa chiều rộng trừ đi nửa độ dày nét. Bỏ phép trừ này thì nét vẽ sẽ tràn ra mép khung và bị cắt.

Đây là toàn bộ file với painter đã ráp vào, phần tính góc vẫn được comment lại để code biên dịch và chạy được:

import 'package:flutter/material.dart';
// import 'dart:math' as math;

const Color darkBlue = Color.fromARGB(255, 18, 32, 47);

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      theme: ThemeData.dark().copyWith(scaffoldBackgroundColor: darkBlue),
      debugShowCheckedModeBanner: false,
      home: const Scaffold(
        body: Center(
          child: ProgressIndicatorButton(),
        ),
      ),
    );
  }
}

class ProgressIndicatorButton extends StatelessWidget {
  const ProgressIndicatorButton({
    Key? key,
//     required this.startAngle,
//     required this.endAngle,
  }) : super(key: key);

//   final double startAngle;
//   final double endAngle;

  @override
  Widget build(BuildContext context) {
    const buttonSize = 80.0;
    const borderWidth = 2.0;

    return Stack(
      children: [
        Container(
          width: buttonSize,
          height: buttonSize,
          decoration: BoxDecoration(
            shape: BoxShape.circle,
            border: Border.all(
              color: Colors.white,
              width: borderWidth,
            ),
          ),
        ),
        SizedBox(
          width: buttonSize,
          height: buttonSize,
          child: CustomPaint(
            painter: ProgressIndicatorPainter(
              width: borderWidth,
//               startAngle: startAngle,
//               sweepAngle: endAngle,
            ),
            child: Center(
              child: Container(
                width: buttonSize - 20.0,
                height: buttonSize - 20.0,
                decoration: const BoxDecoration(
                  color: Colors.blue,
                  shape: BoxShape.circle,
                ),
                child: const Center(
                  child: Icon(
                    Icons.done,
                    size: 30.0,
                  ),
                ),
              ),
            ),
          ),
        ),
      ],
    );
  }
}

class ProgressIndicatorPainter extends CustomPainter {
  const ProgressIndicatorPainter({
    required this.width,
//     required this.startAngle,
//     required this.sweepAngle,
  }) : super();

  final double width;
//   final double startAngle;
//   final double sweepAngle;

  @override
  void paint(Canvas canvas, Size size) {
    final paint = Paint()
      ..color = Colors.blue
      ..strokeCap = StrokeCap.butt
      ..style = PaintingStyle.stroke
      ..strokeWidth = width;

    final center = Offset(size.width / 2, size.height / 2);
    final radius = (size.width / 2) - (width / 2);

//     canvas.drawArc(
//       Rect.fromCircle(center: center, radius: radius),
//       startAngle,
//       sweepAngle,
//       false,
//       paint,
//     );
  }

  @override
  bool shouldRepaint(CustomPainter oldDelegate) => false;
}

Hãy giữ nguyên các dòng comment đúng vị trí — bỏ comment một nửa thì sẽ lỗi biên dịch.

startAngle và sweepAngle thực sự là gì

Đây là phần đáng đi chậm lại.

startAngle tính bằng radian và bắt đầu từ 0 — tức vị trí 3 giờ trên đường tròn đơn vị. Điểm gây bẫy là chiều: drawArc quét theo chiều kim đồng hồ, trong khi đường tròn đơn vị bạn học ở trường chạy ngược chiều kim đồng hồ. Thay vì suy luận lại từ đầu, mẹo là cứ đọc vị trí trên đường tròn đơn vị như bình thường rồi thêm dấu âm. Muốn cung bắt đầu ở π/2 (vị trí 12 giờ)? Truyền -π/2.

sweepAngle không phải vị trí kết thúc — nó là độ dài. Giá trị bạn truyền được cộng vào startAngle, và tổng đó mới là nơi cung dừng. Muốn vẽ từ π/2 về 0 thì cần startAngle: -π/2 và sweepAngle: π/2, vì −π/2 + π/2 = 0.

Tính sweep cho một cung bất kỳ

Lấy vòng cung ở đầu bài: nó bắt đầu quanh 2π/3 và kết thúc quanh 11π/6 trên đường tròn đơn vị. Không có phép trừ gọn gàng nào luôn cho ra sweep khi start là góc tùy ý, nên hãy đếm cung theo từng lát:

góc phần tư I được phủ trọn → π/2
góc phần tư II và IV mỗi bên góp một lát π/6 → π/6 + π/6

π/6 + π/6 + π/2 = 5π/6, đó chính là sweep. Code đầy đủ:

import 'package:flutter/material.dart';
import 'dart:math' as math;

const Color darkBlue = Color.fromARGB(255, 18, 32, 47);

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      theme: ThemeData.dark().copyWith(scaffoldBackgroundColor: darkBlue),
      debugShowCheckedModeBanner: false,
      home: const Scaffold(
        body: Center(
          child: ProgressIndicatorButton(
            startAngle: -2 * math.pi / 3,
            endAngle: 5 * math.pi / 6,
          ),
        ),
      ),
    );
  }
}

class ProgressIndicatorButton extends StatelessWidget {
  const ProgressIndicatorButton({
    Key? key,
    required this.startAngle,
    required this.endAngle,
  }) : super(key: key);

  final double startAngle;
  final double endAngle;

  @override
  Widget build(BuildContext context) {
    const buttonSize = 80.0;
    const borderWidth = 2.0;

    return Stack(
      children: [
        Container(
          width: buttonSize,
          height: buttonSize,
          decoration: BoxDecoration(
            shape: BoxShape.circle,
            border: Border.all(
              color: Colors.white,
              width: borderWidth,
            ),
          ),
        ),
        SizedBox(
          width: buttonSize,
          height: buttonSize,
          child: CustomPaint(
            painter: ProgressIndicatorPainter(
              width: borderWidth,
              startAngle: startAngle,
              sweepAngle: endAngle,
            ),
            child: Center(
              child: Container(
                width: buttonSize - 20.0,
                height: buttonSize - 20.0,
                decoration: const BoxDecoration(
                  color: Colors.blue,
                  shape: BoxShape.circle,
                ),
                child: const Center(
                  child: Icon(
                    Icons.done,
                    size: 30.0,
                  ),
                ),
              ),
            ),
          ),
        ),
      ],
    );
  }
}

class ProgressIndicatorPainter extends CustomPainter {
  const ProgressIndicatorPainter({
    required this.width,
    required this.startAngle,
    required this.sweepAngle,
  }) : super();

  final double width;
  final double startAngle;
  final double sweepAngle;

  @override
  void paint(Canvas canvas, Size size) {
    final paint = Paint()
      ..color = Colors.blue
      ..strokeCap = StrokeCap.butt
      ..style = PaintingStyle.stroke
      ..strokeWidth = width;

    final center = Offset(size.width / 2, size.height / 2);
    final radius = (size.width / 2) - (width / 2);

    canvas.drawArc(
      Rect.fromCircle(center: center, radius: radius),
      startAngle,
      sweepAngle,
      false,
      paint,
    );
  }

  @override
  bool shouldRepaint(CustomPainter oldDelegate) => false;
}

Thích dùng độ hơn? Đổi ở sát chỗ vẽ

Nếu radian làm code gọi khó đọc, hãy nhận giá trị theo độ vào painter rồi đổi sang radian ngay trước drawArc. Không có gì khác thay đổi — vẫn các khái niệm đó, chỉ là con số dễ chịu hơn.

import 'package:flutter/material.dart';
import 'dart:math' as math;

const Color darkBlue = Color.fromARGB(255, 18, 32, 47);

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      theme: ThemeData.dark().copyWith(scaffoldBackgroundColor: darkBlue),
      debugShowCheckedModeBanner: false,
      home: const Scaffold(
        body: Center(
          child: ProgressIndicatorButton(
            startAngle: -120,
            endAngle: 150,
          ),
        ),
      ),
    );
  }
}

class ProgressIndicatorButton extends StatelessWidget {
  const ProgressIndicatorButton({
    Key? key,
    required this.startAngle,
    required this.endAngle,
  }) : super(key: key);

  final int startAngle;
  final int endAngle;

  @override
  Widget build(BuildContext context) {
    const buttonSize = 80.0;
    const borderWidth = 2.0;

    return Stack(
      children: [
        Container(
          width: buttonSize,
          height: buttonSize,
          decoration: BoxDecoration(
            shape: BoxShape.circle,
            border: Border.all(
              color: Colors.white,
              width: borderWidth,
            ),
          ),
        ),
        SizedBox(
          width: buttonSize,
          height: buttonSize,
          child: CustomPaint(
            painter: ProgressIndicatorPainter(
              width: borderWidth,
              startAngle: startAngle,
              sweepAngle: endAngle,
            ),
            child: Center(
              child: Container(
                width: buttonSize - 20.0,
                height: buttonSize - 20.0,
                decoration: const BoxDecoration(
                  color: Colors.blue,
                  shape: BoxShape.circle,
                ),
                child: const Center(
                  child: Icon(
                    Icons.done,
                    size: 30.0,
                  ),
                ),
              ),
            ),
          ),
        ),
      ],
    );
  }
}

class ProgressIndicatorPainter extends CustomPainter {
  const ProgressIndicatorPainter({
    required this.width,
    required this.startAngle,
    required this.sweepAngle,
  }) : super();

  final double width;
  final int startAngle;
  final int sweepAngle;

  @override
  void paint(Canvas canvas, Size size) {
    final paint = Paint()
      ..color = Colors.blue
      ..strokeCap = StrokeCap.butt
      ..style = PaintingStyle.stroke
      ..strokeWidth = width;

    final startAngleRad = startAngle * (math.pi / 180.0);
    final sweepAngleRad = sweepAngle * (math.pi / 180.0);

    final center = Offset(size.width / 2, size.height / 2);
    final radius = (size.width / 2) - (width / 2);

    canvas.drawArc(
      Rect.fromCircle(center: center, radius: radius),
      startAngleRad,
      sweepAngleRad,
      false,
      paint,
    );
  }

  @override
  bool shouldRepaint(CustomPainter oldDelegate) => false;
}

Hai ví dụ để luyện tay

Cùng quy trình, chỉ khác con số:

Bắt đầu ở vị trí 3 giờ. startAngle là 0 (viết 0.0 trong code cũng được). Sweep phủ trọn góc phần tư IV cộng một lát π/6 của góc phần tư III: π/6 + π/2 = 4π/6.
Bắt đầu ở −5π/4. Ở góc phần tư II lấy trọn quadrant, rồi ở góc phần tư III lấy một lát π/6 và một lát π/12: π/2 + π/6 + π/12 = 3π/4.

Kết luận

Đếm từng lát theo góc phần tư không phải cách thanh lịch nhất để suy ra sweep angle, nhưng nó đáng tin và bạn có thể tính ngay trên giấy cạnh bản thiết kế. Khi vòng cung tĩnh đã đúng, việc thêm animation chỉ là một bước ngắn: điều khiển sweepAngle bằng AnimationController, và đổi shouldRepaint sang so sánh với oldDelegate để Flutter thực sự vẽ lại.

Bài viết gốc đăng tại FlutterCook. Bản trên đó là bản được cập nhật mới nhất.

🌐 English · Tiếng Việt

📌 In summary

Fable is an open-source developer tooling library in the Library/Tooling category.
It has 3,133★ and 329 forks, and is actively maintained (updated within the last month).
Install it with Fable: ^latest in your pubspec.yaml.
Best when you want to automate or streamline part of your build.

🧭 On this page

What is Fable?
Why Fable is worth knowing in 2026
Installing Fable
When should you use Fable?
Fable vs. the alternatives
Frequently asked questions
Resources & links

Fable is an open-source developer tooling library for Flutter mobile app development, with 3,133★ on GitHub and last updated on 2026-07-16. This guide covers what Fable does, why it matters in 2026, how to add it to your project, when to reach for it, and how it compares to the alternatives — plus a quick FAQ.

What is Fable?

F# to JavaScript, TypeScript, Python, Rust, Erlang and Dart Compiler. It focuses on improving your Flutter developer workflow and codebase. The project lives at fable-compiler/Fable and is maintained by fable-compiler.

Why Fable is worth knowing in 2026

Fable carries 3,133 GitHub stars, 329 forks, 173 open issues. It has been around since 2016, and is actively maintained (updated within the last month). For a Library/Tooling option, that combination of adoption and upkeep usually means a healthy community, production usage, and plenty of examples to learn from — the things that make a dependency safe to build on.

Installing Fable

Add the package to your pubspec.yaml:

dependencies:
  Fable: ^latest

Then fetch it and import it in your Dart code:

flutter pub get

import 'package:fable/fable.dart';

Check the package's example/ directory and its GitHub repo for the exact API — Fable is versioned there with full docs so you always integrate against the current release.

When should you use Fable?

Reach for Fable when:

you want to automate or streamline part of your build
you need better debugging, codegen, or DX
you're standardising tooling across a team

It's especially relevant if your project touches beam, dart, erlang, fsharp, javascript, python.

Fable vs. the alternatives

If you're weighing options in the Library/Tooling space, these are the other projects developers most often compare Fable against:

There's no single winner — the right pick depends on your app's size, your team's familiarity, and your performance budget. Browse the full Library/Tooling collection to compare them side by side.

Frequently asked questions

Is Fable free to use?

Yes. Fable is open source and free to use in your Flutter projects. You can view the source, report issues, and contribute on GitHub.

Does Fable work on both iOS and Android?

Fable is built for Flutter, so it targets iOS and Android from a single codebase, and typically web and desktop too depending on the project's platform support.

How popular is Fable?

As of 2026, Fable has around 3,133 stars and 329 forks on GitHub, which puts it among the more widely used options in the Library/Tooling space.

What are good alternatives to Fable?

Popular alternatives in the Library/Tooling category include flclash, ente, nativescript. The best choice depends on your app's size, team, and performance needs.

Resources & links

GitHub: fable-compiler/Fable
Video tutorials: search YouTube for Fable

Part of FlutterCook — 500 hands-on guides to the best open-source Flutter libraries, UI kits, and apps. Explore the live GitHub trends or browse YouTube guides.

🇻🇳 Fable: hướng dẫn thư viện & công cụ trong Flutter

📌 Tóm tắt

Fable là một thư viện & công cụ cho lập trình viên mã nguồn mở thuộc nhóm Library/Tooling.
Dự án có 3,133★ và 329 fork, và được bảo trì tích cực (cập nhật trong tháng qua).
Cài bằng Fable: ^latest trong pubspec.yaml.
Phù hợp nhất khi bạn muốn tự động hóa hoặc tối ưu một phần quy trình build.

🧭 Mục lục

Fable là gì?
Vì sao nên biết Fable trong năm 2026
Cài đặt Fable
Khi nào nên dùng Fable?
Fable so với các lựa chọn thay thế
Câu hỏi thường gặp
Tài nguyên & liên kết

Fable là một thư viện & công cụ cho lập trình viên mã nguồn mở cho phát triển ứng dụng di động Flutter, với 3,133★ trên GitHub và cập nhật lần cuối ngày 2026-07-16. Bài viết này trình bày Fable làm gì, vì sao đáng quan tâm năm 2026, cách thêm vào dự án, khi nào nên dùng, so sánh với các lựa chọn thay thế — kèm phần FAQ ngắn.

Fable là gì?

F# to JavaScript, TypeScript, Python, Rust, Erlang and Dart Compiler. Nó tập trung vào việc cải thiện quy trình phát triển và chất lượng mã Flutter. Dự án nằm tại fable-compiler/Fable và được duy trì bởi fable-compiler.

Vì sao nên biết Fable trong năm 2026

Fable có 3,133 sao GitHub, 329 fork, 173 issue đang mở. Dự án tồn tại từ năm 2016 và được bảo trì tích cực (cập nhật trong tháng qua). Với một lựa chọn thư viện & công cụ, mức độ được dùng và bảo trì như vậy thường đồng nghĩa với cộng đồng khỏe mạnh, được dùng thực tế và nhiều ví dụ để học.

Cài đặt Fable

Thêm gói vào pubspec.yaml:

dependencies:
  Fable: ^latest

Rồi tải về và import trong mã Dart:

flutter pub get

import 'package:fable/fable.dart';

Xem thư mục example/ và repo GitHub để biết API chính xác — Fable được đánh phiên bản kèm tài liệu đầy đủ nên bạn luôn tích hợp đúng bản phát hành hiện tại.

Khi nào nên dùng Fable?

Hãy chọn Fable khi:

bạn muốn tự động hóa hoặc tối ưu một phần quy trình build
bạn cần debug, sinh mã hoặc trải nghiệm lập trình tốt hơn
bạn chuẩn hóa công cụ cho cả nhóm

Đặc biệt phù hợp nếu dự án của bạn liên quan tới beam, dart, erlang, fsharp, javascript, python.

Fable so với các lựa chọn thay thế

Nếu bạn đang cân nhắc các lựa chọn trong nhóm thư viện & công cụ, đây là những dự án thường được đem ra so sánh với Fable:

Không có lựa chọn nào thắng tuyệt đối — điều đó tùy quy mô app, mức quen thuộc của đội ngũ và ngân sách hiệu năng. Xem toàn bộ nhóm thư viện & công cụ để so sánh trực tiếp.

Câu hỏi thường gặp

Fable có miễn phí không?

Có. Fable là mã nguồn mở và miễn phí dùng trong dự án Flutter của bạn. Bạn có thể xem mã nguồn, báo lỗi và đóng góp trên GitHub.

Fable có chạy trên cả iOS và Android không?

Fable được xây cho Flutter nên chạy trên iOS và Android từ một codebase duy nhất, và thường cả web lẫn desktop tùy mức hỗ trợ nền tảng của dự án.

Fable phổ biến đến mức nào?

Tính đến 2026, Fable có khoảng 3,133 sao và 329 lượt fork trên GitHub, thuộc nhóm được dùng nhiều trong mảng thư viện & công cụ.

Có lựa chọn nào thay thế Fable?

Các lựa chọn phổ biến trong nhóm thư viện & công cụ gồm flclash, ente, nativescript. Lựa chọn tốt nhất tùy vào quy mô app, đội ngũ và yêu cầu hiệu năng của bạn.

Tài nguyên & liên kết

GitHub: fable-compiler/Fable
Video hướng dẫn: tìm Fable trên YouTube

Thuộc FlutterCook — 500 hướng dẫn thực hành về các thư viện, UI kit và ứng dụng Flutter mã nguồn mở tốt nhất. Xem xu hướng GitHub hoặc hướng dẫn YouTube.

Originally published on FlutterCook — 500 open-source Flutter recipes, AI-first · song ngữ Anh/Việt.

Subscribe to: Posts ( Atom )