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,
    );
  });
}

HttpClient client = HttpClient();
client.getUrl(Uri.parse("https://yrom.net/"))
    .then((HttpClientRequest request) => request.close())
    .then((HttpClientResponse response) {
        print('Response status: ${response.statusCode}');
        response.transform(utf8.decoder).listen((contents) {
         print('${contents}');
       });
    });
// client.close();

import 'package:http/http.dart';

Client client = Client();
var url = 'https://yrom.net';
var response = await client.get(url);
print('Response status: ${response.statusCode}');
print('Response body: ${response.body}');

print(await client.read('https://yrom.net'));

// client.close();

import 'package:http/http.dart' as http;

var url = 'https://jsonplaceholder.typicode.com/posts';
var response = await http.get(url);
print('Response status: ${response.statusCode}');
print('Response body: ${response.body}');

print(await http.read('https://jsonplaceholder.typicode.com/posts/1'));

class AWidgetState extends State<AWidget> {
  // ...
  var data;
  void loadData() async {
    var response = await requestApi(...);
    setState((){
      this.data = response.data;
    })
  }
}

class AWidgetState extends State {
  // ...
  var data;
  void loadData() async {
    var response = await requestApi(...);
    if (mounted) {
      setState((){
        this.data = response.data;
      })
    }
  }
}

@override
void initState(){
  WidgetsBinding.instance.addPostFrameCallback((_) {
    if (mounted) _animationController.forward();
  });
}

@override
void initState(){
  _animationController.animation.addListener(_handleAnimationTick);
}

void _handleAnimationTick() {
  if (mounted) updateWidget(...);
}