class WidgetA extends StatefulWidget {
  ...
  @override
  _WidgetAState createState() => _WidgetAState();
}

class _WidgetAState extends State<WidgetA> {
  @override
  Widget build(BuildContext context) {
    return GestureDetector(
      onTap: () async {
        var r = await fetchResult();
        if (mounted) {
            setState(() {
                this.result = r;
            });
        }
      },
      child: ...
    );
  }
}

class _WidgetAState extends State<WidgetA> {
  @override
  void initState() {
    super.initState();
    Provider.of<AuthStateBloc>(context).stream.listen(onAuthStateChanged);
  }
  void onAuthStateChanged(AuthState state) {
    if (mounted) {
      setState(() {
        this.state = state;
      });
    }
  }

import 'dart:ui';

Future<Image> decodeRawRgba(ByteData bytes, int width, int height) {
  final Completer<Image> completer = Completer<Image>();
  decodeImageFromPixels(
    bytes.buffer.asUint8List(),
    width,
    height,
    PixelFormat.rgba8888,
    completer.complete,
  );
  return completer.future;
}

class MemoryImage extends ImageProvider<MemoryImage> {
  @override
  ImageStreamCompleter load(MemoryImage key, DecoderCallback decode) {
    return MultiFrameImageStreamCompleter(
      codec: _loadAsync(key, decode),
      scale: key.scale,
      debugLabel: 'MemoryImage(${describeIdentity(key.bytes)})',
    );
  }

  Future<ui.Codec> _loadAsync(MemoryImage key, DecoderCallback decode) {
    return decode(bytes);
  }
}

import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'package:http2/http2.dart';

void main() async {
  var uri = Uri.parse('https://cn.bing.com/search?q=http2');
  var transport = await connectTunnel('127.0.0.1', 8888, uri.host);
  var headers = [
    Header.ascii(':method', 'GET'),
    Header.ascii(':path', uri.hasQuery ? uri.path + '?' + uri.query : uri.path),
    Header.ascii(':scheme', uri.scheme),
    Header.ascii(':authority', uri.host),
  ];
  var stream = transport.makeRequest(headers, endStream: true);
  var bodyStream = StreamController<List<int>>();
  utf8.decoder.bind(bodyStream.stream).listen((body) {
    print(body);
  });
  await for (var message in stream.incomingMessages) {
    if (message is HeadersStreamMessage) {
      for (var header in message.headers) {
        var name = utf8.decode(header.name);
        var value = utf8.decode(header.value);
        print('Header: $name: $value');
      }
    } else if (message is DataStreamMessage) {
      bodyStream.add(message.bytes);
      if (message.endStream) {
        bodyStream.close();
      }
    }
  }
  if (!bodyStream.isClosed) {
    await bodyStream.close();
  }
  await transport.finish();
}

Future<ClientTransportConnection> connectTunnel(String proxyHost, int proxyPort, String targetHost,
    [int targetPort = 443]) async {
  var proxy = await Socket.connect(proxyHost, proxyPort, timeout: const Duration(seconds: 1));
  const CRLF = "\r\n";
  proxy.write("CONNECT $targetHost:$targetPort HTTP/1.1"); // request line
  proxy.write(CRLF);
  proxy.write("Host: $targetHost:$targetPort"); // header
  proxy.write(CRLF);
  proxy.write(CRLF);
  var completer = Completer<bool>.sync();
  var sub = proxy.listen((event) {
    var response = ascii.decode(event);
    var lines = response.split(CRLF);
    // status line
    var statusLine = lines.first;
    if (statusLine.startsWith("HTTP/1.1 200")) {
      completer.complete();
    } else {
      completer.completeError(statusLine);
    }
  }, onError: completer.completeError);
  await completer.future; // established
  await sub.pause();

  var socket = await SecureSocket.secure(proxy, host: targetHost, supportedProtocols: const ["h2"]);
  return ClientTransportConnection.viaSocket(socket);
}

const double size = 56;

class BubbleAnimationByAnimationController extends StatefulWidget {
  @override
  _BubbleAnimationByAnimationControllerState createState() => _BubbleAnimationByAnimationControllerState();
}

class _BubbleAnimationByAnimationControllerState extends State<BubbleAnimationByAnimationController>
    with SingleTickerProviderStateMixin {
  AnimationController _controller;

  @override
  void initState() {
    super.initState();
    _controller = AnimationController(
      duration: const Duration(seconds: 1),
      vsync: this,
    )..addListener(() => setState(() {}));
    _controller.repeat(reverse: true);
  }

  @override
  void dispose() {
    _controller.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    // 两个 `Container` 对应两个圈
    return Container( 
      alignment: Alignment.center,
      constraints: BoxConstraints.tight(
        Size.square((1 + _controller.value * 0.2) * size),
      ),
      decoration: BoxDecoration(
        shape: BoxShape.circle,
        color: Colors.blue[200],
      ),
      child: Container(
        alignment: Alignment.center,
        padding: const EdgeInsets.all(8.0),
        decoration: BoxDecoration(
          shape: BoxShape.circle,
          color: Colors.blue,
        ),
        width: size,
        height: size,
        child: Text(
          'Hello world!',
          style: TextStyle(color: Colors.white, fontSize: 12),
        ),
      ),
    );
  }
}

import 'logging.dart';
void main() {
  // config logger before runApp()
  initLogging();
  runApp(MyApp());

  // log a debug message
  log.fine('Running my flutter app.');
}

import 'package:logging/logging.dart';

// create Logger by name 'MyApp'
final log = Logger('MyApp');
void initLogging() {
  // disable hierarchical logger
  hierarchicalLoggingEnabled = false;
  // change to another level as needed.
  Logger.root.level = Level.INFO;
  // skip logging stactrace below the SEVERE level.
  recordStackTraceAtLevel = Level.SEVERE;
  assert(() {
    recordStackTraceAtLevel = Level.WARNING;
    // print all logs on debug build.
    Logger.root.level = Level.ALL;
    return true;
  }());
}

Logger.root.onRecord.listen((event) {
  print("${event.time}: [${event.level}] [${event.loggerName}] ${event.message}");
});

File logFile = ...
Logger.root.onRecord.listen((event) {
  logFile.writeAsString("${event.time}: [${event.level}] [${event.loggerName}] ${event.message}",
    mode: FileMode.append);
});

import 'dart:developer' as developer;

void initLogging() {
  ...
  Logger.root.onRecord.listen((event) {
    developer.log(
      event.message,
      time: event.time,
      sequenceNumber: event.sequenceNumber,
      level: event.level.value,
      name: event.loggerName,
      zone: event.zone,
      error: event.error,
      stackTrace: event.stackTrace,
    );
  });
}