flutter泛型,float型

flutter-动画

1.动画原理：在一段时间内快速的多次改变UI外观，由于人眼会产生视觉暂留所以最终看到的就是一个连续的动画。

成都创新互联公司是一家专业从事成都网站设计、成都做网站、网页设计的品牌网络公司。如今是成都地区具影响力的网站设计公司,作为专业的成都网站建设公司,成都创新互联公司依托强大的技术实力、以及多年的网站运营经验,为您提供专业的成都网站建设、营销型网站建设及网站设计开发服务！

UI的一次改变称为一个动画帧，对应一次屏幕刷新。

FPS：帧率，每秒的动画帧数。

flutter动画分为两类：

常见动画模式：

是一个抽象类，主要的功能是保存动画的值和状态。常用的一个Animation类是Animation double ,是一个在一段时间内依次生成一个区间之间的值的类，可以是线性或者曲线或者其他。

可以生成除double之外的其他类型值，如：Animation Color 或 Animation Size 。

是一个动画控制器，控制动画的播放状态，在屏幕刷新的每一帧，就会生成一个新的值。

包含动画的启动forward()、停止stop() 、反向播放 reverse()等方法，在给定的时间段内线性的生成从0.0到1.0（默认区间）的数字。

curve:描述动画的曲线过程。

curvedAnimation:指定动画的曲线。

常用Curve：

继承自Animatable T ，表示的就是一个 Animation 对象的取值范围，只需要设置开始和结束的边界值(值也支持泛型)。 它唯一的工作就是定义输入范围到输出范围的映射。

例如，Tween可能会生成从红到蓝之间的色值，或者从0到255。

Tween.animate:返回一个Animation。

映射过程：

1). Tween.animation通过传入 aniamtionController 获得一个_AnimatedEvaluation 类型的 animation 对象(基类为 Animation)， 并且将 aniamtionController 和 Tween 对象传入了 _AnimatedEvaluation 对象。

2). animation.value方法即是调用 _evaluatable.evaluate(parent)方法， 而 _evaluatable 和 parent 分别为 Tween 对象和 AnimationController 对象。

3). 这里的 animation 其实就是前面的 AnimationController 对象， transform 方法里面的 animation.value则就是 AnimationController 线性生成的 0.0~1.0 直接的值。 在 lerp 方法里面我们可以看到这个 0.0~1.0 的值被映射到了 begin 和 end 范围内了。

接收一个TickerProvider类型的对象，它的主要职责是创建Ticker。

防止屏幕外动画消耗资源。

[图片上传失败...(image-115b94-1636441483468)]

过程：

回调：

不使用addListener()和setState()来给widget添加动画。

使用AnimatedWidget，将widget分离出来，创建一个可重用动画的widget，AnimatedWidget中会自动调用addListener()和setState()

AnimatedModalBarrier、DecoratedBoxTransition、FadeTransition、PositionedTransition、RelativePositionedTransition、RotationTransition、ScaleTransition、SizeTransition、SlideTransition

如何渲染过渡，把渲染过程也抽象出来：

AnimatedBuilder的示例包括: BottomSheet、 PopupMenu、ProgressIndicator、RefreshIndicator、Scaffold、SnackBar、TabBar。

MaterialPageRoute：平台风格一致的路由切换动画

CupertinoPageRoute：左右切换风格

自定义：PageRouteBuilder

1.要创建交织动画，需要使用多个动画对象（Animation）。

2.一个AnimationController控制所有的动画对象。

3.给每一个动画对象指定时间间隔（Interval）

可以同时对其新、旧子元素添加显示、隐藏动画.

当AnimatedSwitcher的child发生变化时（类型或Key不同），旧child会执行隐藏动画，新child会执行执行显示动画。

希望大家支持一下，感谢

Flutter 小技巧之优化你使用的 BuildContext

Flutter 里的 BuildContext 相信大家都不会陌生，虽然它叫 Context，但是它实际是 Element 的抽象对象，而在 Flutter 里，它主要来自于 ComponentElement 。

关于 ComponentElement 可以简单介绍一下，在 Flutter 里根据 Element 可以简单地被归纳为两类：

所以一般情况下，我们在 build 方法或者 State 里获取到的 BuildContext 其实就是 ComponentElement 。

那使用 BuildContext 有什么需要注意的问题 ？

首先如下代码所示，在该例子里当用户点击 FloatingActionButton 的时候，代码里做了一个 2秒的延迟，然后才调用 pop 退出当前页面。

正常情况下是不会有什么问题，但是当用户在点击了 FloatingActionButton 之后，又马上点击了 AppBar 返回退出应用，这时候就会出现以下的错误提示。

可以看到此时 log 说，Widget 对应的 Element 已经不在了，因为在 Navigator.of(context) 被调用时， context 对应的 Element 已经随着我们的退出销毁。

一般情况下处理这个问题也很简单， 那就是增加 mounted 判断，通过 mounted 判断就可以避免上述的错误 。

上面代码里的 mounted 标识位来自于 State ， 因为 State 是依附于 Element 创建，所以它可以感知 Element 的生命周期 ，例如 mounted 就是判断 _element != null; 。

那么到这里我们收获了一个小技巧： 使用 BuildContext 时，在必须时我们需要通过 mounted 来保证它的有效性 。

那么单纯使用 mounted 就可以满足 context 优化的要求了吗 ？

如下代码所示，在这个例子里：

由于在 5 秒之内，Item 被划出了屏幕，所以对应的 Elment 其实是被释放了，从而由于 mounted 判断， SnackBar 不会被弹出。

那如果假设需要在开发时展示点击数据上报的结果，也就是 Item 被释放了还需要弹出，这时候需要如何处理 ？

我们知道不管是 ScaffoldMessenger.of(context) 还是 Navigator.of(context) ，它本质还是通过 context 去往上查找对应的 InheritedWidget 泛型，所以其实我们可以提前获取。

所以，如下代码所示，在 Future.delayed 之前我们就通过 ScaffoldMessenger.of(context); 获取到 sm 对象，之后就算你直接退出当前的列表页面，5秒过后 SnackBar 也能正常弹出。

为什么页面销毁了，但是 SnackBar 还能正常弹出 ？

因为此时通过 of(context); 获取到的 ScaffoldMessenger 是存在 MaterialApp 里，所以就算页面销毁了也不影响 SnackBar 的执行。

但是如果我们修改例子，如下代码所示，在 Scaffold 上面多嵌套一个 ScaffoldMessenger ，这时候在 Item 里通过 ScaffoldMessenger.of(context) 获取到的就会是当前页面下的 ScaffoldMessenger 。

这种情况下我们只能保证Item 不可见的时候 SnackBar 还能正常弹出， 而如果这时候我们直接退出页面，还是会出现以下的错误提示，因为 ScaffoldMessenger 也被销毁了 。

所以到这里我们收获第二个小技巧： 在异步操作里使用 of(context) ，可以提前获取，之后再做异步操作，这样可以尽量保证流程可以完整执行 。

既然我们说到通过 of(context) 去获取上层共享往下共享的 InheritedWidget ，那在哪里获取就比较好 ？

还记得前面的 log 吗？在第一个例子出错时，log 里就提示了一个方法，也就是 State 的 didChangeDependencies 方法。

为什么是官方会建议在这个方法里去调用 of(context) ？

首先前面我们一直说，通过 of(context) 获取到的是 InheritedWidget ，而 当 InheritedWidget 发生改变时，就是通过触发绑定过的 Element 里 State 的 didChangeDependencies 来触发更新， 所以在 didChangeDependencies 里调用 of(context) 有较好的因果关系 。

那我能在 initState 里提前调用吗 ？

当然不行，首先如果在 initState 直接调用如 ScaffoldMessenger.of(context).showSnackBar 方法，就会看到以下的错误提示。

这是因为 Element 里会判断此时的 _StateLifecycle 状态，如果此时是 _StateLifecycle.created 或者 _StateLifecycle.defunct ，也就是在 initState 和 dispose ，是不允许执行 of(context) 操作。

当然，如果你硬是想在 initState 下调用也行，增加一个 Future 执行就可以成功执行

那我在 build 里直接调用不行吗 ？

直接在 build 里调用肯定可以，虽然 build 会被比较频繁执行，但是 of(context) 操作其实就是在一个 map 里通过 key - value 获取泛型对象，所以对性能不会有太大的影响。

真正对性能有影响的是 of(context) 的绑定数量和获取到对象之后的自定义逻辑 ，例如你通过 MediaQuery.of(context).size 获取到屏幕大小之后，通过一系列复杂计算来定位你的控件。

例如上面这段代码，可能会导致键盘在弹出的时候，虽然当前页面并没有完全展示，但是也会导致你的控件不断重新计算从而出现卡顿。

所以到这里我们又收获了一个小技巧： 对于 of(context) 的相关操作逻辑，可以尽量放到 didChangeDependencies 里去处理 。

Flutter GetX基础教程（十二）：RxList、Rx([])、.obs对比分析

首先我们知道 GetX 组件里面 obs 状态管理有三种创建属性的方式，我们这里以 List 为例

视频讲解链接

我们声明了一个类ListController 继承自 GetxController ，用于属性创建以及状态通知的方法，首先我们用三种方式来创建属性并且通过 convertToUpperCase 方法进行对值的改变，然后我们通过调用 update()`方法来进行数据更新，最后我们使用该属性状态的值，接下来我们看一下三种使用方式的对比。

import 'dart:convert';

import 'package:get/get.dart';

class ListController extends GetxController {

// 第一种

final listOne = RxListMap([

{

"name": "Jimi",

"age": 18

}

]);

// 第二种

final listTwo = RxList([

{

"name": "Jimi",

"age": 18

}

]);

// 第三种

final listThree = [{

"name": "Jimi",

"age": 18

}].obs;

void convertToUpperCase() {

listOne.value[0]["name"] = listOne.value.first["name"].toUpperCase();

listTwo.toList().first["name"] = listTwo.toList().first["name"].toString().toUpperCase();

listThree.toList().first["name"] = listTwo.toList().first["name"].toString().toUpperCase();

update();

}

}

我们在页面中获取状态更新的值

import 'package:flutter/material.dart';

import 'package:flutter_getx_dvanced_example/ListController.dart';

import 'package:get/get.dart';

void main() {

runApp(MyApp());

}

class MyApp extends StatelessWidget {

ListController listController = Get.put(ListController());

@override

Widget build(BuildContext context) {

return GetMaterialApp(

title: "GetX",

home: Scaffold(

appBar: AppBar(

title: Text("GetX"),

),

body: Center(

child: Column(

mainAxisAlignment: MainAxisAlignment.center,

crossAxisAlignment: CrossAxisAlignment.center,

children: [

GetBuilderListController(

init: listController,

builder: (controller) {

return Text(

"我的名字是 {controller.listTwo.first['name']}",

style: TextStyle(color: Colors.green, fontSize: 30),

);

},

),

SizedBox(height: 20,),

GetBuilderListController(

init: listController,

builder: (controller) {

return Text(

"我的名字是 ${controller.listThree.first['name']}",

style: TextStyle(color: Colors.green, fontSize: 30),

);

},

),

SizedBox(height: 20,),

ElevatedButton(

onPressed: () {

listController.convertToUpperCase();

},

child: Text("转换为大写"))

],

),

),

),

);

}

}

/pre

|`

效果展示

RxT 继承自 _RxImplT ， _RxImplT 又继承 RxNotifierT 并混合 RxObjectMixinT 类

RxImplT 它主要的作用是管理泛型的所有逻辑的。

RxObjectMixinT 它主要的作用是管理注册到 GetX 和 Obx 的全局对象，比如 Widget 的 Rx 值

RxT 它主要的作用是将自定义模型类用Rx`来进行包装，

class RxT extends _RxImplT {

Rx(T initial) : super(initial);

@override

dynamic toJson() {

try {

return (value as dynamic)?.toJson();

} on Exception catch (_) {

throw '$T has not method [toJson]';

}

}

}

abstract class _RxImplT extends RxNotifierT with RxObjectMixinT {

_RxImpl(T initial) {

_value = initial;

}

void addError(Object error, [StackTrace? stackTrace]) {

subject.addError(error, stackTrace);

}

StreamR mapR(R mapper(T? data)) = stream.map(mapper);

void update(void fn(T? val)) {

fn(_value);

subject.add(_value);

}

void trigger(T v) {

var firstRebuild = this.firstRebuild;

value = v;

if (!firstRebuild) {

subject.add(v);

}

}

}

/pre

|`

RxListE 继承自 ListMixinE 实现了 RxInterfaceListE 并混合了 NotifyManagerListE, RxObjectMixinListE

RxListE 它的主要作用是创建一个类似于 ListT 的一个列表

class RxListE extends ListMixinE

with NotifyManagerListE, RxObjectMixinListE

implements RxInterfaceListE {

RxList([ListE initial = const []]) {

_value = List.from(initial);

}

factory RxList.filled(int length, E fill, {bool growable = false}) {

return RxList(List.filled(length, fill, growable: growable));

}

factory RxList.empty({bool growable = false}) {

return RxList(List.empty(growable: growable));

}

/// Creates a list containing all [elements].

factory RxList.from(Iterable elements, {bool growable = true}) {

return RxList(List.from(elements, growable: growable));

}

/// Creates a list from [elements].

factory RxList.of(IterableE elements, {bool growable = true}) {

return RxList(List.of(elements, growable: growable));

}

/// Generates a list of values.

factory RxList.generate(int length, E generator(int index),

{bool growable = true}) {

return RxList(List.generate(length, generator, growable: growable));

}

/// Creates an unmodifiable list containing all [elements].

factory RxList.unmodifiable(Iterable elements) {

return RxList(List.unmodifiable(elements));

}

@override

IteratorE get iterator = value.iterator;

@override

void operator []=(int index, E val) {

_value[index] = val;

refresh();

}

/// Special override to push() element(s) in a reactive way

/// inside the List,

@override

RxListE operator +(IterableE val) {

addAll(val);

refresh();

return this;

}

@override

E operator [](int index) {

return value[index];

}

@override

void add(E item) {

_value.add(item);

refresh();

}

@override

void addAll(IterableE item) {

_value.addAll(item);

refresh();

}

@override

int get length = value.length;

@override

@protected

ListE get value {

RxInterface.proxy?.addListener(subject);

return _value;

}

@override

set length(int newLength) {

_value.length = newLength;

refresh();

}

@override

void insertAll(int index, IterableE iterable) {

_value.insertAll(index, iterable);

refresh();

}

@override

IterableE get reversed = value.reversed;

@override

IterableE where(bool Function(E) test) {

return value.where(test);

}

@override

IterableT whereTypeT() {

return value.whereTypeT();

}

@override

void sort([int compare(E a, E b)?]) {

_value.sort(compare);

refresh();

}

}

/pre

|`

当我们在调用 .obs 的时候其实内部的实现源码还是通过 RxListe(this) 进行了一层包装，设计这个主要的目的就是为了方便开发者进行使用

ListExtensionE on ListE {

RxListE get obs = RxListE(this);

/// Add [item] to [ListE] only if [item] is not null.

void addNonNull(E item) {

if (item != null) add(item);

}

// /// Add [IterableE] to [ListE] only if [IterableE] is not null.

// void addAllNonNull(IterableE item) {

// if (item != null) addAll(item);

// }

/// Add [item] to ListE only if [condition] is true.

void addIf(dynamic condition, E item) {

if (condition is Condition) condition = condition();

if (condition is bool condition) add(item);

}

/// Adds [IterableE] to [ListE] only if [condition] is true.

void addAllIf(dynamic condition, IterableE items) {

if (condition is Condition) condition = condition();

if (condition is bool condition) addAll(items);

}

/// Replaces all existing items of this list with [item]

void assign(E item) {

// if (this is RxList) {

// (this as RxList)._value;

// }

}

/// Replaces all existing items of this list with [items]

void assignAll(IterableE items) {

// if (this is RxList) {

// (this as RxList)._value;

// }

clear();

addAll(items);

}

}

/pre

|`

我们对 RxT([]) 、 RxListE 、 .obs 进行了一个总结，在我们平时的开发过程中建议大家使用 .obs 即可，因为这是最简单的方式。

FlutterJsonBeanFactory插件json使用

使用注解@JSONField

其中name: "list"的list就是后台返回字段名称,deserialize(默认true)是否参与fromJson解析,serialize(默认true)是否参与tojson,

比如包含如下json

可以解析出来list中map的所有字段,并且每个list的map字段不同或者为null问题有会做出处理

helper文件内容

直接传递上面生成的entity就可以自动根据map解析出对应实例,并自动赋值

网络请求实例

dio请求部分

这些操作完成后自动生成如下文件

@JSONField作用在Field时，其name不仅定义了输入key的名称,为了防止后台返回数据不规范,但是flutter端需要按照驼峰命名

a_b_c_entity_helper.dart类提供了eitity类的tojson和fromjson代理方法

json_convert_content.dart提供了json_convert_content.dart.fromJsonAsT方法 根据泛型来解析json成对象

Flutter进阶篇（4）-- Flutter的Future异步详解

本文首发在公众号 Flutter那些事 ，欢迎大家多多关注。

工具安装：

Flutter基础篇：

Flutter进阶篇：

Dart语法基础篇：

Dart语法进阶篇：

说明：本文中的所有函数的引用在 main 函数中：

这里的执行结果是：

Futue直接new就可以了。我这里没有具体的返回数据，所以就用匿名函数代替了， Future future = new Future(() = null); 相当于 FutureNull future = new Future(() = null); 泛型如果为null可以省略不写，为了便于维护和管理，开发中建议加上泛型。

输出结果是：

future里面有几个函数：

then ：异步操作逻辑在这里写。

whenComplete ：异步完成时的回调。

catchError ：捕获异常或者异步出错时的回调。

因为这里面的异步操作过程中没有遇到什么错误，所以catchError回调不会调用。

我们可以看到执行结果是：

我们可以看到输出结果是： 2 1 3 和我们创建Future对象的先后顺序完全一致。

我们可以看到结果为 1 2 3 ，和我们调用then的先后顺序无关。：

当then回调函数里面还有then回调的时候，这时候的流程跟前面就不太一样了，也是一个大坑，也是面试经常会被问到的一个知识点。

我们可以看到执行结果如下：

结果还是一样的：

运行结果是：

这里再次证明了上面我的猜想： 执行顺序和和创建Future的先后顺序有关，如果有多个then嵌套执行，先执行外面的then，然后执行里面的then。

执行结果如下，我们可以看到then内部创建的Future要等到then执行完了，最后再去执行的：

根据上文总结的特点，我们可以不用运行也能推断出输出结果：

为了验证我们的猜想，我们打印一下输出结果，果然我们的证明是正确的。

我们重点看看 then函数的文档说明：

then 注册在 Future 完成时调用的回调。

当这个 Future 用一个 value 完成时，将使用该值调用 onValue 回调。

如果 Future 已经完成，则不会立即调用回调，而是将在稍后的 microtask（微任务） 中调度。

如果回调返回 Future ，那么 then 返回的 future 将与 callback 返回的 future 结果相同。

onError 回调必须接受一个参数或两个参数，后者是[StackTrace]。

如果 onError 接受两个参数，则使用错误和堆栈跟踪时调用它，否则仅使用错误对象时候调用它。

onError 回调必须返回一个可用于完成返回的future的值或future，因此它必须是可赋值给 FutureOr R 的东西。

返回一个新的 Future ，该 Future 是通过调用 onValue (如果这个Future是通过一个value完成的)或' onError (如果这个Future是通过一个error完成的)的结果完成的。

如果调用的回调抛出异常，返回的 future 将使用抛出的错误和错误的堆栈跟踪完成。在 onError 的情况下，如果抛出的异常与 onError 的错误参数“相同(identical)”，则视为重新抛出，并使用原始堆栈跟踪替代

如果回调返回 Future ，则 then 返回的 Future 将以与回调返回的 Future 相同的结果完成。

如果未给出 onError ，并且后续程序走了刚出现了错误，则错误将直接转发给返回的 Future 。

在大多数情况下，单独使用 catchError 更可读，可能使用 test 参数，而不是在单个 then 调用中同时处理 value 和 error 。

请注意，在添加监听器(listener)之前， future 不会延迟报告错误。如果第一个 then 或 catchError 调用在 future 完成后发生 error ，那么 error 将报告为未处理的错误。

Flutter 热重载未生效

将枚举类型更改为常规类或将常规类更改为枚举类型时，热重载(r)不起作用。 需要hot restart(cmd + shift + r)

修改泛型类型声明后，热重装将无法工作。 例如，以下操作将无效：

Widget 快速替换 、 包装 、 移动 、 删除 、 抽取成变量 、 抽取成方法

焦点放到相应的widget上, 然后 cmd + . 如果提示没有相关操作,多试几次