Flutter 在Flatter中的Firestore列表上方添加搜索表单

我试图在Firestore的项目列表上方呈现一个搜索表单，并根据表单中键入的内容进行本地筛选

我尝试像这样将这两个小部件添加到正文中，但它只显示搜索表单：

body: Column(
    children: <Widget>[Searchform(), ContentWidget()],
),

body:Column(
子项：[Searchform（），ContentWidget（）]，
),

这是显示基本列表的当前代码：

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

class Items extends StatefulWidget {
  Items({Key key}) : super(key: key);

  @override
  _ItemsState createState() => _ItemsState();
}

class _ItemsState extends State<Items> {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Search'),
      ),
      body: ContentWidget(),
    );
  }
}

class Searchform extends StatelessWidget {
  final TextEditingController _searchController = TextEditingController();

  @override
  Widget build(BuildContext context) {
    return TextField(
      controller: _searchController,
      decoration: InputDecoration(
        labelText: "Search",
        hintText: "Search",
        prefixIcon: Icon(Icons.search),
        border: OutlineInputBorder(
          borderRadius: BorderRadius.all(
            Radius.circular(15.0),
          ),
        ),
      ),
    );
  }
}

class ContentWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return StreamBuilder<QuerySnapshot>(
      stream: Firestore.instance.collection('content').snapshots(),
      builder: (BuildContext context, AsyncSnapshot<QuerySnapshot> snapshot) {
        if (snapshot.hasError) return new Text('Error: ${snapshot.error}');
        switch (snapshot.connectionState) {
          case ConnectionState.waiting:
            return new Text('Loading...');
          default:
            return new ListView(
              children:
                  snapshot.data.documents.map((DocumentSnapshot document) {
                return new ListTile(
                  title: new Text(document['term']),
                );
              }).toList(),
            );
        }
      },
    );
  }
}

导入“包装：颤振/材料.省道”；
导入“包：cloud_firestore/cloud_firestore.dart”；
类项扩展StatefulWidget{
项目（{Key}）：超级（Key:Key）；
@凌驾
_ItemsState createState（）=>\u ItemsState（）；
}
类_ItemsState扩展状态{
@凌驾
小部件构建（构建上下文）{
返回脚手架(
appBar:appBar(
标题：文本（“搜索”），
),
正文：ContentWidget（），
);
}
}
类Searchform扩展了无状态小部件{
最终TextEditingController _searchController=TextEditingController（）；
@凌驾
小部件构建（构建上下文）{
返回文本字段(
控制器：\ u搜索控制器，
装饰：输入装饰(
labelText:“搜索”，
hintText:“搜索”，
前缀：图标（Icons.search），
边框：大纲输入边框(
borderRadius:borderRadius.all(
圆形半径（15.0），
),
),
),
);
}
}
类ContentWidget扩展了无状态Widget{
@凌驾
小部件构建（构建上下文）{
返回流生成器(
流：Firestore.instance.collection（'content'）.snapshots（），
生成器：（BuildContext上下文，异步快照）{
if（snapshot.hasError）返回新文本（'Error:${snapshot.Error}'）；
交换机（快照.连接状态）{
案例连接状态。正在等待：
返回新文本（'加载…'）；
违约：
返回新的ListView(
儿童：
snapshot.data.documents.map（（DocumentSnapshot文档）{
返回新的ListTile(
标题：新文本（文件[‘术语]），
);
}).toList（），
);
}
},
);
}
}

---

我想做的是将项目保存在本地状态，并根据搜索框中键入的内容进行过滤

我已经在listview代码中提供了简单的过滤记录

class FilterDemo extends StatefulWidget {
@override
State<StatefulWidget> createState() {
// TODO: implement createState
return FilterState();
}
}

class FilterState extends State<FilterDemo> {
List<String> items, duplicateList;
TextEditingController editingController = TextEditingController();

@override
 void initState() {
// TODO: implement initState
super.initState();
items = List<String>.generate(1000, (i) => "Item $i");

duplicateList = items;
}

void filterSearchResults(String query) {
List<String> dummySearchList = List<String>();
dummySearchList.addAll(duplicateList);
if (query.isNotEmpty) {
  List<String> dummyListData = List<String>();
  dummySearchList.forEach((item) {
    if (item.contains(query)) {
      dummyListData.add(item);
    }
  });
  setState(() {
    items.clear();
    items.addAll(dummyListData);
  });
  return;
} else {
  setState(() {
    items.clear();
    items.addAll(duplicateList);
  });
}
}

@override
Widget build(BuildContext context) {
// TODO: implement build
return Scaffold(
  appBar: AppBar(
    title: Text("Filter Demo"),
  ),
  body: Column(
    children: <Widget>[
      Padding(
        padding: const EdgeInsets.all(8.0),
        child: TextField(
          onChanged: (value) {
            filterSearchResults(value);
          },
          controller: editingController,
          decoration: InputDecoration(
              labelText: "Search",
              hintText: "Search",
              prefixIcon: Icon(Icons.search),
              border: OutlineInputBorder(
                  borderRadius: BorderRadius.all(Radius.circular(25.0)))),
        ),
      ),
      Expanded(
        child: ListView.builder(
          itemCount: items.length,
          itemBuilder: (context, index) {
            return ListTile(
              title: Text('${items[index]}'),
            );
          },
        ),
      ),
    ],
  ),
);
}
}

class FilterDemo扩展StatefulWidget{
@凌驾
状态createState（）{
//TODO:实现createState
返回FilterState（）；
}
}
类FilterState扩展状态{
列表项，重复列表；
TextEditingController编辑控制器=TextEditingController（）；
@凌驾
void initState（）{
//TODO:实现initState
super.initState（）；
项目=列表。生成（1000，（i）=>“项目$i”）；
重复列表=项目；
}
无效筛选器搜索结果（字符串查询）{
List dummySearchList=List（）；
dummySearchList.addAll（重复列表）；
if（query.isNotEmpty）{
List dummyListData=List（）；
dummySearchList.forEach（（项目）{
if（项包含（查询））{
dummyListData.add（项）；
}
});
设置状态（）{
items.clear（）；
items.addAll（dummyListData）；
});
返回；
}否则{
设置状态（）{
items.clear（）；
items.addAll（重复列表）；
});
}
}
@凌驾
小部件构建（构建上下文）{
//TODO:实现构建
返回脚手架(
appBar:appBar(
标题：文本（“过滤器演示”），
),
正文：专栏(
儿童：[
填充物(
填充：常数边集全部（8.0），
孩子：TextField(
一旦更改：（值）{
过滤器搜索结果（值）；
},
控制器：编辑控制器，
装饰：输入装饰(
labelText:“搜索”，
hintText:“搜索”，
前缀：图标（Icons.search），
边框：大纲输入边框(
borderRadius:borderRadius.all（半径.圆形（25.0）），
),
),
扩大(
子项：ListView.builder(
itemCount:items.length，
itemBuilder：（上下文，索引）{
返回列表块(
标题：文本（“${items[index]}”），
);
},
),
),
],
),
);
}
}

我提供了如何将项目保存在本地状态的代码，并根据搜索框中键入的内容对其进行过滤。

     class UserList extends StatefulWidget {
          final FirebaseUser user;
          final String currentUserId;
          UserList({this.currentUserId, this.user});
          @override
          _UserListState createState() => _UserListState();
        }

        class _UserListState extends State<UserList> {
          TextEditingController _signUpConfirmPassword = new TextEditingController();
          String _myValue = '';

          UniqueKey _myKey = UniqueKey();
          @override
          Widget build(BuildContext context) {
            return CupertinoPageScaffold(
                navigationBar: CupertinoNavigationBar(
                  middle: Text("UserList"),
                ),
                child: ListView(
                  shrinkWrap: true,
                  children: <Widget>[
                    Padding(
                        padding: EdgeInsets.all(10.0),
                        child: CupertinoTextField(
                          keyboardType: TextInputType.text,
                          //inputFormatters: [LengthLimitingTextInputFormatter(60)],
                          placeholder: 'Search For..',
        //                  placeholderStyle: TextStyle(
        //                      fontWeight: FontWeight.w200
        //                  ),
                          prefix: Padding(
                            padding: EdgeInsets.only(left: 10.0),
                            child: Icon(
                              Icons.search,
                            ),
                          ),
                          onChanged: (val) {
                            if (val.isNotEmpty) {
                              _myValue = val;
                            }
                            setState(() {
                              _myKey = UniqueKey();
                            });
                          },
                          decoration: BoxDecoration(
                              border: Border.all(color: primaryColor),
                              borderRadius: BorderRadius.circular(20.0)),
                        )),
                    SizedBox(height: 10.0),
                    Container(
                        key: _myKey,
                        child: FetchUsers(
                          user: widget.user,
                          myValue: _myValue,
                        )),
                  ],
                ));
          }
        }

        class FetchUsers extends StatefulWidget {
          final String myValue;
          final FirebaseUser user;
          FetchUsers({this.myValue, this.user});
          @override
          _FetchUsersState createState() => _FetchUsersState();
        }

        class _FetchUsersState extends State<FetchUsers> {
          List searchName = List();
          List userName = List();
          Future listOfUsers() {
            if (widget.myValue.isEmpty) {
              return Firestore.instance
                  .collection('users')
                  .where('Role', isEqualTo: 'user')
                  .orderBy('Created', descending: true)
                  .limit(10)
                  .getDocuments()
                  .then((d) {
                userName.clear();
                d.documents.forEach((f) {
                  userName.add(f);
                });
                return userName;
              });
            } else {
              return Firestore.instance
                  .collection('users')
                  .where('Role', isEqualTo: 'user')
                  .limit(10)
                  .getDocuments()
                  .then((d) {
                searchName.clear();
                d.documents.forEach((f) {
                  if (f.data['Name']
                      .toString()
                      .toLowerCase()
                      .contains(widget.myValue.toLowerCase())) {
                    searchName.add(f);
                  }
                });

                return searchName;
              });
            }
          }

          @override
          Widget build(BuildContext context) {
            return FutureBuilder(
              future: listOfUsers(),
              builder: (context, snapshot) {
                if (!snapshot.hasData) {
                  return Center(
                    child: CupertinoActivityIndicator(),
                  );
                } else {
                  return ListView.separated(
                    physics: ClampingScrollPhysics(),
                    separatorBuilder: (context, int) {
                      return Divider();
                    },
                    itemCount: snapshot.data.length,
                    shrinkWrap: true,
                    padding: EdgeInsets.all(10.0),
                    itemBuilder: (context, index) {
                      return Card(
                          elevation: 7.0,
                          shape: RoundedRectangleBorder(
                              borderRadius: BorderRadius.circular(10.0)),
                          child: IntrinsicHeight(
                            child: Padding(
                              padding: const EdgeInsets.all(10.0),
                              child: Row(
                                crossAxisAlignment: CrossAxisAlignment.stretch,
                                children: <Widget>[
                                  Column(
                                    mainAxisAlignment: MainAxisAlignment.center,
                                    crossAxisAlignment: CrossAxisAlignment.start,
                                    children: <Widget>[
                                      Text(
                                        '   ${snapshot.data[index]['Name']}',
                                        style: TextStyle(
                                            color: outlineColor,
                                            fontWeight: FontWeight.bold),
                                      ),
                                      SizedBox(
                                        height: 5.0,
                                      ),
                                      Text(
                                        '   ${snapshot.data[index]['Email']}',
                                      ),
                                    ],
                                  ),
                                  Spacer(),
                                  Column(
                                    crossAxisAlignment: CrossAxisAlignment.start,
                                    children: <Widget>[
                                      RaisedButton.icon(
                                          shape: RoundedRectangleBorder(
                                              borderRadius:
                                                  BorderRadius.circular(20.0)),
                                          color: primaryColor,
                                          onPressed: () {
                                            Navigator.push(
                                                context,
                                                CupertinoPageRoute(
                                                    builder: (context) => Chat(
                                                          user: widget.user,
                                                          name: snapshot.data[index]
                                                              ['Name'],
                                                          peerId: snapshot.data[index]
                                                              ['UID'],
                                                        )));
                                          },
                                          icon: Icon(
                                            Icons.chat,
                                            color: themeColor,
                                          ),
                                          label: Text(
                                            "Chat",
                                            style: TextStyle(color: themeColor),
                                          )),
                                      RaisedButton.icon(
                                          shape: RoundedRectangleBorder(
                                              borderRadius:
                                                  BorderRadius.circular(20.0)),
                                          color: primaryColor,
                                          onPressed: () {
                                            Navigator.push(
                                                context,
                                                CupertinoPageRoute(
                                                    builder: (context) =>
                                                        SendNotificationOption(
                                                          name: snapshot.data[index]
                                                              ['Name'],
                                                          myFcm: snapshot.data[index]
                                                              ['UID'],
                                                          isBroadcast: false,
                                                        )));
                                          },
                                          icon: Icon(
                                            Icons.notifications,
                                            color: themeColor,
                                          ),
                                          label: Text(
                                            "Notification",
                                            style: TextStyle(color: themeColor),
                                          )),
                                    ],
                                  ),
                                ],
                              ),
                            ),
                          ));
                    },
                  );
                }
              },
            );
          }
        }

class用户列表扩展StatefulWidget{
最终FirebaseUser用户；
最终字符串currentUserId；
用户列表（{this.currentUserId，this.user}）；
@凌驾
_UserListState createState（）=>\u UserListState（）；
}
类_UserListState扩展状态{
TextEditingController_signUpConfirmPassword=新的TextEditingController（）；
字符串_myValue=''；
UniqueKey _myKey=UniqueKey（）；
@凌驾
小部件构建（构建上下文）{
返回式CupertinoPageScaffold(
导航栏：CupertinoNavigationBar(
中间：文本（“用户列表”），
),
子：ListView(
收缩膜：对，
儿童：[
填充物(
填充：所有边缘设置（10.0），
孩子：CupertinoTextField(
键盘类型：TextInputType.text，
//inputFormatters:[LengthLimitingTextInputFormatter（60）]，
占位符：“搜索…”，
//占位符样式：文本样式(
//fontWeight:fontWeight.w200
//                  ),
前缀：填充(
填充：仅限边缘设置（左：10.0），
子：图标(
Icons.search，
),
),
一旦更改：（val）{
if（val.isNotEmpty）{
_我的价值
if(_searchController.text.toString().contains(document['term'])){
  return new ListTile(
      title: new Text(document['term']),
    );
}