0
点赞
收藏
分享

微信扫一扫

Flutter了解之功能性组件

目录
  1. 导航返回拦截(WillPopScope)
  2. 数据共享(InheritedWidget)
  3. 跨组件状态共享(Provider)
  4. 颜色和主题(Color、Theme)
  5. 异步UI更新(FutureBuilder、StreamBuilder)

Flutter官方并没有对Widget进行官方分类,对其分类主要是为了对Widget进行功能区分。

功能性组件指的是不会影响UI布局及外观的Widget,它们通常具有一定的功能,如FocusScope(焦点控制)、PageStorage(数据存储)、NotificationListener(事件监听)。

1. 导航返回拦截(WillPopScope)

为了避免用户误触返回按钮而导致APP退出,在很多APP中都拦截了用户点击返回键的按钮,然后进行一些防误触判断,比如当用户在某一个时间段内点击两次时,才会认为用户是要退出(而非误触)。

Flutter中可以通过WillPopScope来实现返回按钮拦截。

const WillPopScope({
  @required WillPopCallback onWillPop, // 一个回调函数,当用户点击返回按钮时被调用(包括导航返回按钮及Android物理返回按钮)。该回调需要返回一个Future对象,如果返回的Future最终值为false时,则当前路由不出栈(不会返回);最终值为true时,当前路由出栈退出。
  @required Widget child
})

为了防止用户误触返回键退出,拦截返回事件,当用户在1秒内点击两次返回按钮时,则退出;如果间隔超过1秒则不退出,并重新记时。

import 'package:flutter/material.dart';
class WillPopScopeTestRoute extends StatefulWidget {
  @override
  WillPopScopeTestRouteState createState() {
    return new WillPopScopeTestRouteState();
  }
}
class WillPopScopeTestRouteState extends State<WillPopScopeTestRoute> {
  DateTime _lastPressedAt; //上次点击时间
  @override
  Widget build(BuildContext context) {
    return new WillPopScope(
        onWillPop: () async {
          if (_lastPressedAt == null ||
              DateTime.now().difference(_lastPressedAt) > Duration(seconds: 1)) {
            //两次点击间隔超过1秒则重新计时
            _lastPressedAt = DateTime.now();
            return false;
          }
          return true;
        },
        child: Container(
          alignment: Alignment.center,
          child: Text("1秒内连续按两次返回键退出"),
        )
    );
  }
}

2. 数据共享(InheritedWidget)

InheritedWidget提供了一种数据在widget树中从上到下传递、共享的方式,和通知Notification的传递方向正好相反。和React中的context功能类似,和逐级传递数据相比,它们能实现组件跨级传递数据。

在应用的根widget中通过InheritedWidget共享了一个数据,那么便可以在任意子widget中来获取该共享的数据。
Flutter SDK中正是通过InheritedWidget来共享Theme(应用主题)和Locale (当前语言环境)信息的。

StatefulWidget的State对象有一个didChangeDependencies回调,它会在“依赖”发生变化时被Flutter Framework调用,在该回调中更新UI。而这个“依赖”指的就是子widget是否使用了父widget中InheritedWidget的数据!如果使用了,则代表子widget依赖有依赖InheritedWidget;如果没有使用则代表没有依赖。
比如当主题、locale(语言)等发生变化时,依赖其的子widget的didChangeDependencies方法将会被调用。

一般来说,子widget很少会重写didChangeDependencies方法,因为在依赖改变后framework也都会调用build()方法。但是,如果需要在依赖改变后执行一些昂贵的操作,比如网络请求,这时最好的方式就是在此方法中执行,这样可以避免每次build()都执行这些昂贵操作。

通过继承InheritedWidget,将当前计数器点击次数保存在ShareDataWidget的data属性中

class ShareDataWidget extends InheritedWidget {
  final int data; // 需要在子树中共享的数据,保存点击次数
  ShareDataWidget({
    @required this.data,
    Widget child
  }) :super(child: child);
  // 定义一个便捷方法,方便子树中的widget获取共享数据  
  static ShareDataWidget of(BuildContext context) {
    return context.dependOnInheritedWidgetOfExactType<ShareDataWidget>();
  }
  // 该回调决定当data发生变化时,是否通知子树中依赖data的Widget  
  @override
  bool updateShouldNotify(ShareDataWidget old) {
    // 如果返回true,则子树中依赖(build函数中有调用)本widget的子widget的`state.didChangeDependencies`会被调用
    return old.data != data;
  }
}

实现一个子组件_TestWidget,在其build方法中引用ShareDataWidget中的数据。同时,在其didChangeDependencies() 回调中打印日志:
class _TestWidget extends StatefulWidget {
  @override
  _TestWidgetState createState() => new _TestWidgetState();
}
class _TestWidgetState extends State<_TestWidget> {
  @override
  Widget build(BuildContext context) {
    // 使用InheritedWidget中的共享数据
    return Text(ShareDataWidget
        .of(context)
        .data
        .toString());
  }
  @override
  void didChangeDependencies() {
    super.didChangeDependencies();
    // 父或祖先widget中的InheritedWidget改变(updateShouldNotify返回true)时会被调用。
    // 如果build中没有依赖InheritedWidget,则此回调不会被调用。
    print("Dependencies change");
  }
}


创建一个按钮,每点击一次,就将ShareDataWidget的值自增
class InheritedWidgetTestRoute extends StatefulWidget {
  @override
  _InheritedWidgetTestRouteState createState() => new _InheritedWidgetTestRouteState();
}
class _InheritedWidgetTestRouteState extends State<InheritedWidgetTestRoute> {
  int count = 0;
  @override
  Widget build(BuildContext context) {
    return  Center(
      child: ShareDataWidget( //使用ShareDataWidget
        data: count,
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            Padding(
              padding: const EdgeInsets.only(bottom: 20.0),
              child: _TestWidget(),// 子widget中依赖ShareDataWidget
            ),
            RaisedButton(
              child: Text("Increment"),
              // 每点击一次,将count自增,然后重新build,ShareDataWidget的data将被更新  
              onPressed: () => setState(() => ++count),
            )
          ],
        ),
      ),
    );
  }
}
每点击一次按钮,计数器就会自增,控制台就会打印一句日志:Dependencies change

深入了解InheritedWidget

如果只想在_TestWidgetState中引用ShareDataWidget数据,但却不希望在ShareDataWidget发生变化时调用_TestWidgetState的didChangeDependencies()方法,只需要将ShareDataWidget.of()的实现改一下即可:
// 定义一个便捷方法,方便子树中的widget获取共享数据
static ShareDataWidget of(BuildContext context) {
  // return context.dependOnInheritedWidgetOfExactType<ShareDataWidget>();
  // 唯一的改动就是获取ShareDataWidget对象的方式,把dependOnInheritedWidgetOfExactType()方法换成了context.getElementForInheritedWidgetOfExactType<ShareDataWidget>().widget
  return context.getElementForInheritedWidgetOfExactType<ShareDataWidget>().widget;
}


getElementForInheritedWidgetOfExactType方法的定义:
@override
InheritedElement getElementForInheritedWidgetOfExactType<T extends InheritedWidget>() {
  assert(_debugCheckStateIsActiveForAncestorLookup());
  final InheritedElement ancestor = _inheritedWidgets == null ? null : _inheritedWidgets[T];
  return ancestor;
}


dependOnInheritedWidgetOfExactType方法的定义:
@override
InheritedWidget dependOnInheritedWidgetOfExactType({ Object aspect }) {
  assert(_debugCheckStateIsActiveForAncestorLookup());
  final InheritedElement ancestor = _inheritedWidgets == null ? null : _inheritedWidgets[T];
  // 多出的部分
  if (ancestor != null) {
    assert(ancestor is InheritedElement);
    return dependOnInheritedElement(ancestor, aspect: aspect) as T;
  }
  _hadUnsatisfiedDependencies = true;
  return null;
}


可以看到,dependOnInheritedWidgetOfExactType() 比 getElementForInheritedWidgetOfExactType()多调了dependOnInheritedElement方法。


dependOnInheritedElement方法的定义:
  @override
  InheritedWidget dependOnInheritedElement(InheritedElement ancestor, { Object aspect }) {
    assert(ancestor != null);
    _dependencies ??= HashSet<InheritedElement>();
    _dependencies.add(ancestor);
    ancestor.updateDependencies(this, aspect);
    return ancestor.widget;
  }
可以看到dependOnInheritedElement方法中主要是注册了依赖关系!所以在调用dependOnInheritedWidgetOfExactType()时,InheritedWidget和依赖它的子孙组件关系便完成了注册,之后当InheritedWidget发生变化时,就会更新依赖它的子孙组件,也就是会调这些子孙组件的didChangeDependencies()方法和build()方法。而当调用的是 getElementForInheritedWidgetOfExactType()时,由于没有注册依赖关系,所以之后当InheritedWidget发生变化时,就不会更新相应的子孙Widget。

3. 跨组件状态共享(Provider)

状态管理,一般的原则是:如果状态是组件私有的,则应该由组件自己管理;如果状态要跨组件共享,则该状态应该由各个组件共同的父元素来管理。

全局事件总线EventBus:
一个观察者模式的实现。通过它就可以实现跨组件状态同步:状态持有方(发布者)负责更新状态,状态使用方(观察者)监听状态改变事件来执行一些操作。


定义事件:
enum Event{
  login,
  ... //省略其它事件
}


登录页:
// 登录状态改变后发布状态改变事件
bus.emit(Event.login);


依赖登录状态的页面:
@override
void initState() {
  // 订阅登录状态改变事件
  bus.on(Event.login,onLogin);
  super.initState();
}
@override
void dispose() {
  // 取消订阅
  bus.off(Event.login,onLogin);
  super.dispose();
}
void onLogin(e){
  // 登录状态变化处理逻辑
}
通过上述观察者模式来实现跨组件状态共享有一些明显的缺点:
    1. 必须显式定义各种事件,不好管理。
    2. 订阅者必须需显式注册状态改变回调,也必须在组件销毁时手动去解绑回调以避免内存泄露。

更好的跨组件状态管理方式: InheritedWidget。
  将需要跨组件共享的状态保存在InheritedWidget中,然后在子组件中引用InheritedWidget,当InheritedWidget数据发生变化时,可以自动更新依赖它的子孙组件。  

Provider库正是基于InheritedWidget实现的一套跨组件状态共享解决方案。

Model变化后会自动通知ChangeNotifierProvider订阅者,ChangeNotifierProvider内部会重新构建InheritedWidget,而依赖该InheritedWidget的子孙Widget就会更新。

使用Provider的好处:
    1. 业务代码更关注数据了,只要更新Model,则UI会自动更新,而不用在状态改变后再去手动调用setState()来显式更新页面。
    2. 数据改变的消息传递被屏蔽了,无需手动去处理状态改变事件的发布和订阅了,这一切都被封装在Provider中了。
    3. 在大型复杂应用中,尤其是需要全局共享的状态非常多时,使用Provider将会大大简化代码逻辑,降低出错的概率,提高开发效率。

首先,需要一个保存需要跨组件共享数据的InheritedWidget。

由于具体业务数据类型不可预期,为了通用性,使用泛型,定义一个通用的InheritedProvider类,它继承自InheritedWidget。

class InheritedProvider<T> extends InheritedWidget {
  InheritedProvider({@required this.data, Widget child}) : super(child: child);
  // 共享状态使用泛型
  final T data;
  @override
  bool updateShouldNotify(InheritedProvider<T> old) {
    // 在此简单返回true,则每次更新都会调用依赖其的子孙节点的`didChangeDependencies`。
    return true;
  }
}

接下来,需要做的就是在数据发生变化的时候来重新构建InheritedProvider。

数据发生变化可以使用eventBus来进行事件通知(不推荐),也可以使用ChangeNotifier类(继承自Listenable,实现了一个Flutter风格的发布者-订阅者模式)。
将要共享的状态放到一个Model类中,然后让它继承自ChangeNotifier,这样当共享的状态改变时,只需要调用notifyListeners() 来通知订阅者,然后由订阅者来重新构建InheritedProvider。
/*
ChangeNotifier定义大致如下:

class ChangeNotifier implements Listenable {
  List listeners=[];
  @override
  void addListener(VoidCallback listener) {
     // 添加监听器
     listeners.add(listener);
  }
  @override
  void removeListener(VoidCallback listener) {
    // 移除监听器
    listeners.remove(listener);
  }
  void notifyListeners() {
    // 通知所有监听器,触发所有监听器回调 
    listeners.forEach((item)=>item());
  }
  ... // 省略无关代码
}
*/

订阅者
class ChangeNotifierProvider<T extends ChangeNotifier> extends StatefulWidget {
  ChangeNotifierProvider({
    Key key,
    this.data,
    this.child,
  });
  final Widget child;
  final T data;
  // 定义了一个of()静态方法供子类方便获取Widget树中的InheritedProvider中保存的共享状态
  static T of<T>(BuildContext context) {
    final type = _typeOf<InheritedProvider<T>>();
    final provider =  context.dependOnInheritedWidgetOfExactType<InheritedProvider<T>>();
    return provider.data;
  }
  @override
  _ChangeNotifierProviderState<T> createState() => _ChangeNotifierProviderState<T>();
}
// 主要作用就是监听到共享状态改变时重新构建Widget树。
class _ChangeNotifierProviderState<T extends ChangeNotifier> extends State<ChangeNotifierProvider<T>> {
  void update() {
    // 如果数据发生变化(model类调用了notifyListeners),重新构建InheritedProvider
    setState(() => {
    });
  }
  @override
  void didUpdateWidget(ChangeNotifierProvider<T> oldWidget) {
    // 当Provider更新时,如果新旧数据不"==",则解绑旧数据监听,同时添加新数据监听
    if (widget.data != oldWidget.data) {
      oldWidget.data.removeListener(update);
      widget.data.addListener(update);
    }
    super.didUpdateWidget(oldWidget);
  }
  @override
  void initState() {
    // 给model添加监听器
    widget.data.addListener(update);
    super.initState();
  }
  @override
  void dispose() {
    // 移除model的监听器
    widget.data.removeListener(update);
    super.dispose();
  }
  @override
  Widget build(BuildContext context) { // 重新执行该build方法widget.child不会去更新
    return InheritedProvider<T>(
      data: widget.data,
      child: widget.child,  
    );
  }
}

通过一个购物车的例子来使用上面这些类

向购物车中添加新商品时总价更新

定义一个Item类,用于表示商品信息:
class Item {
  Item(this.price, this.count);
  double price; // 商品单价
  int count; // 商品份数
  //... 省略其它属性
}

定义一个保存购物车内商品数据的CartModel类:
// CartModel即要跨组件共享的model类
class CartModel extends ChangeNotifier {
  // 用于保存购物车中商品列表
  final List<Item> _items = [];
  // 禁止改变购物车里的商品信息
  UnmodifiableListView<Item> get items => UnmodifiableListView(_items);
  // 购物车中商品的总价
  double get totalPrice =>
      _items.fold(0, (value, item) => value + item.count * item.price);
  // 将 [item] 添加到购物车。这是唯一一种能从外部改变购物车的方法。
  void add(Item item) {
    _items.add(item);
    // 通知监听器(订阅者),重新构建InheritedProvider, 更新状态。
    notifyListeners();
  }
}

构建示例页面:
class ProviderRoute extends StatefulWidget {
  @override
  _ProviderRouteState createState() => _ProviderRouteState();
}
class _ProviderRouteState extends State<ProviderRoute> {
  @override
  Widget build(BuildContext context) {
    return Center(
      child: ChangeNotifierProvider<CartModel>(
        data: CartModel(),
        child: Builder(builder: (context) {
          return Column(
            children: <Widget>[
              Builder(builder: (context){
                var cart=ChangeNotifierProvider.of<CartModel>(context);
                return Text("总价: ${cart.totalPrice}");
              }),
              Builder(builder: (context){
                print("RaisedButton build"); 
                return RaisedButton(
                  child: Text("添加商品"),
                  onPressed: () {
                    // 给购物车中添加商品,添加后总价会更新
                    ChangeNotifierProvider.of<CartModel>(context).add(Item(20.0, 1));
                  },
                );
              }),
            ],
          );
        }),
      ),
    );
  }
}

每次点击”添加商品“按钮,总价就会增加20

就这个例子来看,只是更新同一个路由页中的一个状态,使用ChangeNotifierProvider的优势并不明显,但是如果是做一个购物APP呢?由于购物车数据是通常是会在整个APP中共享的,比如会跨路由共享。如果将ChangeNotifierProvider放在整个应用的Widget树的根上,那么整个APP就可以共享购物车的数据了,这时ChangeNotifierProvider的优势将会非常明显。

上面实现的ChangeNotifierProvider是有两个明显缺点:代码组织问题和性能问题

先看一下构建显示总价Text的代码:
Builder(builder: (context){
  var cart=ChangeNotifierProvider.of<CartModel>(context);
  return Text("总价: ${cart.totalPrice}");
})

这段代码有两点可以优化:
    1. 需要显式调用ChangeNotifierProvider.of,当APP内部依赖CartModel很多时,这样的代码将很冗余。
    2. 语义不明确;由于ChangeNotifierProvider是订阅者,那么依赖CartModel的Widget自然就是订阅者,其实也就是状态的消费者,如果用Builder 来构建,语义就不是很明确;如果能使用一个具有明确语义的Widget,比如就叫Consumer,这样最终的代码语义将会很明确,只要看到Consumer,就知道它是依赖某个跨组件或全局的状态。

为了优化这两个问题,可以封装一个Consumer Widget

代码组织问题

// 这是一个便捷类,会获得当前context和指定数据类型的Provider
class Consumer<T> extends StatelessWidget {
  Consumer({
    Key key,
    @required this.builder,
    this.child,
  })  : assert(builder != null),
        super(key: key);
  final Widget child;
  final Widget Function(BuildContext context, T value) builder;
  @override
  Widget build(BuildContext context) {
    return builder(
      context,
      ChangeNotifierProvider.of<T>(context), // 自动获取Model
    );
  }
}
Consumer实现非常简单,它通过指定模板参数,然后再内部自动调用ChangeNotifierProvider.of获取相应的Model,并且Consumer这个名字本身也是具有确切语义(消费者)。现在上面的代码块可以优化为如下这样:
Consumer<CartModel>(
  builder: (context, cart)=> Text("总价: ${cart.totalPrice}");
)
性能问题

在构建”添加按钮“的代码处存在性能问题:
点击”添加商品“按钮后,由于购物车商品总价会变化,所以显示总价的Text更新是符合预期的,但是”添加商品“按钮本身没有变化,是不应该被重新build的。
如何避免这不必要重构呢?既然按钮重新被build是因为按钮和InheritedWidget建立了依赖关系,那么只要使用getElementForInheritedWidgetOfExactType()打破或解除这种依赖关系就可以了。

所以只需要将ChangeNotifierProvider.of的实现改为下面这样即可:
 // 添加一个listen参数,表示是否建立依赖关系
 static T of<T>(BuildContext context, {bool listen = true}) {
    final type = _typeOf<InheritedProvider<T>>();
    final provider = listen
        ? context.dependOnInheritedWidgetOfExactType<InheritedProvider<T>>()
        : context.getElementForInheritedWidgetOfExactType<InheritedProvider<T>>()?.widget
            as InheritedProvider<T>;
    return provider.data;
 }

然后将调用部分代码改为:
Column(
    children: <Widget>[
      Consumer<CartModel>(
        builder: (BuildContext context, cart) =>Text("总价: ${cart.totalPrice}"),
      ),
      Builder(builder: (context) {
        print("RaisedButton build");
        return RaisedButton(
          child: Text("添加商品"),
          onPressed: () {
            // listen 设为false,不建立依赖关系
            ChangeNotifierProvider.of<CartModel>(context, listen: false)
                .add(Item(20.0, 1));
          },
        );
      })
    ],
  )

class HelloModel extends Model{
  int _count=0;
  int get count=>_count;

  void increaseCount(){
    _count++;
    notifyListeners();
  }
}

class HelloPageWidget extends StatelessWidget{
  @override
  Widget build(BuildContext context) {
    return ScopedModel(
      model: HelloModel(),
      child: Scaffold(
        appBar: AppBar(
          title: Text('hello'),
          elevation: 1.0,
        ),
        body: HelloWidget(),
        floatingActionButton: ScopedModelDescendant<HelloModel>(
          rebuildOnChange: false, // 不需要重建
          builder: (context,_,model)=>FloatingActionButton(
            child: Icon(Icons.add),
            onPressed: model.increaseCount,
          ),
        ),
      ),
    );
}
class HelloWidget extends StatelessWidget{
  @override
  Widget build(BuildContext context) {
    return HellWorldWidget();
  }
}
class HellWorldWidget extends StatelessWidget{
  @override
  Widget build(BuildContext context) {
    return ScopedModelDescendant<HelloModel>(builder:(context,_,model)=>ActionChip(
      label: Text('${model.count}'),
      onPressed: model.increaseCount,
    ));
  }
}

4. 颜色和主题(Color、Theme)

显示器颜色是由红、绿、蓝三基色组成,每种颜色占8比特:
  0-7蓝色
  8-15绿色
  16-23红色
  24-31Alpha (不透明度)

Flutter的Color类中,颜色以一个int值保存。

// 如果颜色固定可以直接使用整数值
Color(0xffdc380d); 

将颜色字符串转成Color对象:
var c = "dc380d";  // 颜色是一个字符串变量
Color(int.parse(c,radix:16)|0xFF000000) // 通过位运算符将Alpha设置为FF
Color(int.parse(c,radix:16)).withAlpha(255)  // 通过方法将Alpha设置为FF

Colors.black26

实现一个背景颜色和Title可以自定义的导航栏,并且背景色为深色时应该让Title显示为浅色;背景色为浅色时,Title显示为深色。
要实现这个功能,就需要来计算背景色的亮度,然后动态来确定Title的颜色。Color类中提供了一个computeLuminance()方法,它可以返回一个[0-1]的一个值,数字越大颜色就越浅,可以根据它来动态确定Title的颜色.

class NavBar extends StatelessWidget {
  final String title;
  final Color color; //背景颜色

  NavBar({
    Key key,
    this.color,
    this.title,
  });

  @override
  Widget build(BuildContext context) {
    return Container(
      constraints: BoxConstraints(
        minHeight: 52,
        minWidth: double.infinity,
      ),
      decoration: BoxDecoration(
        color: color,
        boxShadow: [
          //阴影
          BoxShadow(
            color: Colors.black26,
            offset: Offset(0, 3),
            blurRadius: 3,
          ),
        ],
      ),
      child: Text(
        title,
        style: TextStyle(
          fontWeight: FontWeight.bold,
          //根据背景色亮度来确定Title颜色
          color: color.computeLuminance() < 0.5 ? Colors.white : Colors.black,
        ),
      ),
      alignment: Alignment.center,
    );
  }
}

Column(
  children: <Widget>[
    //背景为蓝色,则title自动为白色
    NavBar(color: Colors.blue, title: "标题"), 
    //背景为白色,则title自动为黑色
    NavBar(color: Colors.white, title: "标题"),
  ]
)

MaterialColor

实现Material Design中的颜色的类,它包含一种颜色的10个级别的渐变色。
MaterialColor通过"[]"运算符的索引值来代表颜色的深度,有效的索引有:50,100,200,…,900,数字越大,颜色越深。
MaterialColor的默认值为索引等于500的颜色。


例:
Colors.blue是预定义的一个MaterialColor类对象,定义如下:
static const MaterialColor blue = MaterialColor(
  _bluePrimaryValue,
  <int, Color>{
     50: Color(0xFFE3F2FD),
    100: Color(0xFFBBDEFB),
    200: Color(0xFF90CAF9),
    300: Color(0xFF64B5F6),
    400: Color(0xFF42A5F5),
    500: Color(_bluePrimaryValue),
    600: Color(0xFF1E88E5),
    700: Color(0xFF1976D2),
    800: Color(0xFF1565C0),
    900: Color(0xFF0D47A1),
  },
);
static const int _bluePrimaryValue = 0xFF2196F3;

Colors.blue[50]到Colors.blue[900]的色值从浅蓝到深蓝渐变

使用主题可以为共享颜色和字体样式。

ThemeData({
  Brightness brightness, // 亮度(深色还是浅色)
  MaterialColor primarySwatch, // 主题色,它是主题颜色的一个样本色。通过这个样本色可以在一些条件下生成一些其它的属性,例如,如果没有指定primaryColor,并且当前主题不是深色主题,那么primaryColor就会默认为primarySwatch指定的颜色。还有一些相似的属性如accentColor 、indicatorColor等也会受primarySwatch影响。
  Color primaryColor, // 主色,决定导航栏颜色
  Color accentColor, // 次级色(辅助色),决定大多数Widget的颜色,如进度条、开关等。
  Color cardColor, // 卡片颜色
  Color dividerColor, // 分割线颜色
  ButtonThemeData buttonTheme, // 按钮的主题
  Color buttonColor,  // 按钮的颜色
  Color cursorColor, // 输入框光标颜色
  Color dialogBackgroundColor,// 对话框背景颜色
  String fontFamily, // 文字字体
  TextTheme textTheme,// 字体主题,包括标题title、body等文字样式
  IconThemeData iconTheme, // Icon的默认样式
  TargetPlatform platform, // 指定平台,应用特定平台控件风格
  ...
})
/*
const ButtonThemeData({
    this.textTheme = ButtonTextTheme.normal,
    this.minWidth = 88.0,
    this.height = 36.0,
    EdgeInsetsGeometry? padding,
    ShapeBorder? shape,
    this.layoutBehavior = ButtonBarLayoutBehavior.padded,
    this.alignedDropdown = false,
    Color? buttonColor,
    Color? disabledColor,
    Color? focusColor,
    Color? hoverColor,
    Color? highlightColor,
    Color? splashColor,
    this.colorScheme,
    MaterialTapTargetSize? materialTapTargetSize,
  })

BeveledRectangleBorder、StadiumBorder 继承自 OutlinedBorder 继承自 ShapeBorder
const OutlinedBorder({ this.side = BorderSide.none })
const BeveledRectangleBorder({
    BorderSide side = BorderSide.none,
    this.borderRadius = BorderRadius.zero,
  })
const StadiumBorder({ BorderSide side = BorderSide.none })
*/

可以通过ThemeData来自定义应用主题。
Material组件需要遵守相应的设计规范,而这些规范可自定义部分都定义在ThemeData中了。设计规范中有些是不能自定义的,如导航栏高度,ThemeData只包含了可自定义部分。

Material组件库里很多组件都使用了主题数据,如导航栏颜色、标题字体、Icon样式等。定义一个主题后,可以在创建的Widgets中使用它,Flutter提供的Material Widgets将使用该主题为AppBars、Buttons、Checkboxes等设置背景颜色和字体样式。
1、全局主题
由应用程序根MaterialApp创建的Theme。
new MaterialApp(
  title: title,
  theme: new ThemeData(
    brightness: Brightness.dark,
    primaryColor: Colors.lightBlue[800],
    accentColor: Colors.cyan[600],
  ),
);

2、局部主题
方式1(创建新ThemeData)
new Theme(
  data: new ThemeData(
    accentColor: Colors.yellow,
  ),
  child: new FloatingActionButton(
    onPressed: () {},
    child: new Icon(Icons.add),
  ),
);
方式2(扩展父主题)
new Theme(
  data: Theme.of(context).copyWith(accentColor: Colors.yellow),
  child: new FloatingActionButton(
    onPressed: null,
    child: new Icon(Icons.add),
  ),
);

Theme组件可以为Material APP定义主题数据。
Theme内会使用InheritedWidget来为其子树共享样式数据。
在组件build方法中,可以通过Theme.of(BuildContext context)方法来获取当前的ThemeData。
该方法定义如下(简化后的代码,非源码):
    static ThemeData of(BuildContext context, { bool shadowThemeOnly = false }) {
        // context.dependOnInheritedWidgetOfExactType会在widget树中从当前位置向上查找第一个类型为_InheritedTheme的widget,所以局部主题可以覆盖全局主题。
       return context.dependOnInheritedWidgetOfExactType<_InheritedTheme>().theme.data
    }

使用:
new Container(
  color: Theme.of(context).accentColor,
  child: new Text(
    'Text with a background color',
    style: Theme.of(context).textTheme.title,
  ),
);

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';

void main() {
  runApp(new MyApp());
}
class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    final appName = 'Custom Themes';
    return new MaterialApp(
      title: appName,
      theme: new ThemeData(
        brightness: Brightness.dark,
        primaryColor: Colors.lightBlue[800],
        accentColor: Colors.cyan[600],
      ),
      home: new MyHomePage(
        title: appName,
      ),
    );
  }
}

class MyHomePage extends StatelessWidget {
  final String title;
  MyHomePage({Key key, @required this.title}) : super(key: key);
  @override
  Widget build(BuildContext context) {
    return new Scaffold(
      appBar: new AppBar(
        title: new Text(title),
      ),
      body: new Center(
        child: new Container(
          color: Theme.of(context).accentColor,
          child: new Text(
            'Text with a background color',
            style: Theme.of(context).textTheme.title,
          ),
        ),
      ),
      floatingActionButton: new Theme(
        data: Theme.of(context).copyWith(accentColor: Colors.yellow),
        child: new FloatingActionButton(
          onPressed: null,
          child: new Icon(Icons.add),
        ),
      ),
    );
  }
}

本示例是对单个路由换肤,如果想要对整个应用换肤,则可以去修改MaterialApp的theme属性。

class ThemeTestRoute extends StatefulWidget {
  @override
  _ThemeTestRouteState createState() => new _ThemeTestRouteState();
}

class _ThemeTestRouteState extends State<ThemeTestRoute> {
  Color _themeColor = Colors.teal; //当前路由主题色
  @override
  Widget build(BuildContext context) {
    ThemeData themeData = Theme.of(context);
    return Theme(
      data: ThemeData(
          primarySwatch: _themeColor, //用于导航栏、FloatingActionButton的背景色等
          iconTheme: IconThemeData(color: _themeColor) //用于Icon颜色
      ),
      child: Scaffold(
        appBar: AppBar(title: Text("主题测试")),
        body: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            //第一行Icon使用主题中的iconTheme
            Row(
                mainAxisAlignment: MainAxisAlignment.center,
                children: <Widget>[
                  Icon(Icons.favorite),
                  Icon(Icons.airport_shuttle),
                  Text("  颜色跟随主题")
                ]
            ),
            // 通过局部主题覆盖全局主题
            //为第二行Icon自定义颜色(固定为黑色)
            Theme(
              data: themeData.copyWith(
                iconTheme: themeData.iconTheme.copyWith(
                    color: Colors.black
                ),
              ),
              child: Row(
                  mainAxisAlignment: MainAxisAlignment.center,
                  children: <Widget>[
                    Icon(Icons.favorite),
                    Icon(Icons.airport_shuttle),
                    Text("  颜色固定黑色")
                  ]
              ),
            ),
          ],
        ),
        floatingActionButton: FloatingActionButton(
            onPressed: () =>  //切换主题
                setState(() =>
                _themeColor =
                _themeColor == Colors.teal ? Colors.blue : Colors.teal
                ),
            child: Icon(Icons.palette)
        ),
      ),
    );
  }
}


5. 异步数据更新UI(FutureBuilder、StreamBuilder)

很多时候会依赖一些异步数据来动态更新UI:
  1. 在打开一个页面时需要先从互联网上获取数据,在获取数据的过程中显示一个加载框,等获取到数据时再渲染页面;
  2. 想展示Stream(比如文件流、互联网数据接收流)的进度。

FutureBuilder会依赖一个Future,它会根据所依赖的Future的状态来动态构建自身。

FutureBuilder({
  this.future,
  this.initialData,
  @required this.builder,
})

说明:
1.  future
FutureBuilder依赖的Future,通常是一个异步耗时任务。

2. initialData
初始数据,用户设置默认数据。

3. builder
Widget构建器,会在Future执行的不同阶段被多次调用;
构建器签名如下:
  // FutureBuilder的builder构建器签名和StreamBuilder的builder是相同的。
  // snapshot会包含当前异步任务的状态信息及结果信息 ,比如可以通过snapshot.connectionState获取异步任务的状态信息、通过snapshot.hasError判断异步任务是否有错误等等。
  Function (BuildContext context, AsyncSnapshot snapshot)

实现一个路由,当该路由打开时从网上获取数据,获取数据时弹一个加载框;获取结束时,如果成功则显示获取到的数据,如果失败则显示错误。


Future<String> mockNetworkData() async {
  return Future.delayed(Duration(seconds: 2), () => "我是从互联网上获取的数据");
}
...
Widget build(BuildContext context) {
  return Center(
    child: FutureBuilder<String>(
      future: mockNetworkData(),
      builder: (BuildContext context, AsyncSnapshot snapshot) {
        // 请求中
        if (snapshot.connectionState == ConnectionState.waiting) {
          return Center(
            child:Text('加载中...'),
          );
        }
        // 请求已结束
        if (snapshot.connectionState == ConnectionState.done) {
          if (snapshot.hasError) {
            // 请求失败,显示错误
            return Text("Error: ${snapshot.error}");
          } else {
            // 请求成功,显示数据
            return Text("Contents: ${snapshot.data}");
          }
        } else {
          // 请求未结束,显示loading
          return CircularProgressIndicator();
        }
      },
    ),
  );
}

ConnectionState是一个枚举类,定义如下:
enum ConnectionState {
  /// 当前没有异步任务,比如[FutureBuilder]的[future]为null时
  none,
  /// 异步任务处于等待状态
  waiting,
  /// Stream处于激活状态(流上已经有数据传递了),对于FutureBuilder没有该状态。
  /// ConnectionState.active只在StreamBuilder中才会出现。
  active,
  /// 异步任务已经终止.
  done,
}


在Dart中Stream也是用于接收异步事件数据,和Future不同的是,它可以接收多个异步操作的结果,它常用于会多次读取数据的异步任务场景,如网络内容下载、文件读写等。
StreamBuilder正是用于配合Stream来展示流上事件(数据)变化的UI组件。

StreamBuilder({
  Key key,
  this.initialData,  // 初始数据
  Stream<T> stream, // 异步获取数据
  @required this.builder, // 获取到结果后的builder
})

创建一个计时器的示例:每隔1秒,计数加1

Stream<int> counter() {
  return Stream.periodic(Duration(seconds: 1), (i) {
    return i;
  });
}

Widget build(BuildContext context) {
    return StreamBuilder<int>(
      stream: counter(), //
      builder: (BuildContext context, AsyncSnapshot<int> snapshot) {
        if (snapshot.hasError)
          return Text('Error: ${snapshot.error}');
        switch (snapshot.connectionState) {
          case ConnectionState.none:
            return Text('没有Stream');
          case ConnectionState.waiting:
            return Text('等待数据...');
          case ConnectionState.active:
            return Text('active: ${snapshot.data}');
          case ConnectionState.done:
            return Text('Stream已关闭');
        }
        return null; // unreachable
      },
    );
 }
class TestWidget extends StatefulWidget{
  @override
  State<StatefulWidget> createState() {
    return TestWidgetState();
  }
}
class TestWidgetState extends State<TestWidget>{
  StreamSubscription _streamSubscription;

  @override
  void initState() {
    super.initState();

    Stream<String> _helloStream=Stream.fromFuture(fetchData());
    _streamSubscription=_helloStream.listen(onData,onError:onError,onDone:onDone);  // 有数据后、出错后、完成后回调
  }
  void onDone(){
    print('完成');  // 最终都会执行
  }
  void onError(error){
    print('$error');
  }
  void onData(String data){
    print('$data');
  }

  Future<String> fetchData() async{
    await Future.delayed(Duration(seconds: 5)); // 延迟5s
    //
    // throw '出错了';

    return 'hello';
  }

  // 暂停订阅
  void _pauseStream(){
    _streamSubscription.pause();
  }
  // 恢复订阅
  void _resumeStream(){
    _streamSubscription.resume();
  }
  // 取消订阅,取消后无法恢复
  void _cancelStream(){
    _streamSubscription.cancel();
  }

  @override
  Widget build(BuildContext context) {
    return Container(
      child: Center(
        child: Row(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            RaisedButton(
              child: Text('pause'),
              onPressed: _pauseStream,
            ),
            FlatButton(
              child:Text('resume'),
              onPressed: _resumeStream,
            ),
            FlatButton(
              child:Text('cancel'),
              onPressed: _cancelStream,
            ),
          ],
        ),
      ),
    );
  }
}
使用StreamController

StreamController<String> _streamController;

  @override
  void initState() {
    super.initState();
/*
    Stream<String> _helloStream=Stream.fromFuture(fetchData());
    _streamSubscription=_helloStream.listen(onData,onError:onError,onDone:onDone);
 */
    _streamController=StreamController<String>();
    _streamSubscription=_streamController.stream.listen(onData,onError:onError,onDone:onDone);  // 有数据后、出错后、完成后回调
  }

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

    // 关闭stram
    _streamController.close();
  }

  // 向stram中添加数据
  void _addDataToStream() async{
    String data=await fetchData();
    _streamController.add(data);
  }
使用StreamSink

StreamSink _streamSink;

    _streamSink=_streamController.sink;

  // 向stram中添加数据
  void _addDataToStream() async{
    String data=await fetchData();
    // _streamController.add(data);
    _streamSink.add(data);
  }
多次订阅

 _streamController.stream.listen(onTwoData,onError:onError,onDone:onDone);// 有数据后、出错后、完成后回调

  void onTwoData(String data){
    print('two: $data');
  }

class HelloBloc {
  int _count=0;
  //
  final _streamActionController=StreamController<int>();
  StreamSink<int> get countSink=>_streamActionController.sink;
  //
  final _streamController=StreamController<int>();
  Stream<int> get count=>_streamController.stream;

  HelloBloc(){
    _streamActionController.stream.listen(onData);
  }
  void onData(int data){
    print('$data');

    _count=data+_count;
    _streamController.add(_count);
  }

  void dispose(){
    _streamActionController.close();
    _streamController.close();
  }

  void log() {
    print('bloc');
  }
}
class DataProviderWidget extends InheritedWidget {
  final Widget child;
  final HelloBloc dataBlock;
  DataProviderWidget({
    this.child,
    this.dataBlock,
  });

  // 定义一个便捷方法,方便子树中的widget获取共享数据
  static DataProviderWidget of(BuildContext context) {
    return context.dependOnInheritedWidgetOfExactType<DataProviderWidget>();
  }

  @override
  bool updateShouldNotify(DataProviderWidget old) {
    // 如果返回true,则子树中某子widget依赖本widget的dataBlock,则子widget的`state.didChangeDependencies`会被调用
    return true;
  }
}
void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.yellow,
        visualDensity: VisualDensity.adaptivePlatformDensity,
      ),
      home: MyHomePage(),
    );
  }
}
class MyHomePage extends StatefulWidget {
  @override
  createState() => new MyHomePageState();
}
class MyHomePageState extends State<MyHomePage> {
  @override
  Widget build(BuildContext context) {
    return DataProviderWidget(
      child: Scaffold(
        body: TestWidget(),
      ),
      dataBlock: HelloBloc(),
    );
  }
}

class TestWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    HelloBloc _bloc = DataProviderWidget.of(context).dataBlock;
    return Center(
      child: StreamBuilder(
        initialData: 0,
        stream: _bloc.count,
        builder: (context,snapshot){
          return ActionChip(
            label: Text('点击 ${snapshot.data}'),
            onPressed: () {
              _bloc.log();
              _bloc.countSink.add(1);
            },
          );
        },
      ),
    );
  }
}

举报

相关推荐

0 条评论