524 lines
16 KiB
Dart
524 lines
16 KiB
Dart
import 'dart:async';
|
|
import 'dart:collection';
|
|
|
|
import 'package:dynamic_layouts/dynamic_layouts.dart';
|
|
import 'package:flutter/foundation.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter_hbb/desktop/widgets/scroll_wrapper.dart';
|
|
import 'package:get/get.dart';
|
|
import 'package:provider/provider.dart';
|
|
import 'package:visibility_detector/visibility_detector.dart';
|
|
import 'package:window_manager/window_manager.dart';
|
|
import 'package:flutter_hbb/models/peer_tab_model.dart';
|
|
|
|
import '../../common.dart';
|
|
import '../../models/peer_model.dart';
|
|
import '../../models/platform_model.dart';
|
|
import 'peer_card.dart';
|
|
|
|
typedef PeerFilter = bool Function(Peer peer);
|
|
typedef PeerCardBuilder = Widget Function(Peer peer);
|
|
|
|
class PeerSortType {
|
|
static const String remoteId = 'Remote ID';
|
|
static const String remoteHost = 'Remote Host';
|
|
static const String username = 'Username';
|
|
// static const String status = 'Status';
|
|
|
|
static List<String> values = [
|
|
PeerSortType.remoteId,
|
|
PeerSortType.remoteHost,
|
|
PeerSortType.username,
|
|
// PeerSortType.status
|
|
];
|
|
}
|
|
|
|
class LoadEvent {
|
|
static const String recent = 'load_recent_peers';
|
|
static const String favorite = 'load_fav_peers';
|
|
static const String lan = 'load_lan_peers';
|
|
static const String addressBook = 'load_address_book_peers';
|
|
static const String group = 'load_group_peers';
|
|
}
|
|
|
|
/// for peer search text, global obs value
|
|
final peerSearchText = "".obs;
|
|
|
|
/// for peer sort, global obs value
|
|
final peerSort = bind.getLocalFlutterOption(k: 'peer-sorting').obs;
|
|
|
|
// list for listener
|
|
final obslist = [peerSearchText, peerSort].obs;
|
|
|
|
final peerSearchTextController =
|
|
TextEditingController(text: peerSearchText.value);
|
|
|
|
class _PeersView extends StatefulWidget {
|
|
final Peers peers;
|
|
final PeerFilter? peerFilter;
|
|
final PeerCardBuilder peerCardBuilder;
|
|
|
|
const _PeersView(
|
|
{required this.peers,
|
|
required this.peerCardBuilder,
|
|
this.peerFilter,
|
|
Key? key})
|
|
: super(key: key);
|
|
|
|
@override
|
|
_PeersViewState createState() => _PeersViewState();
|
|
}
|
|
|
|
/// State for the peer widget.
|
|
class _PeersViewState extends State<_PeersView> with WindowListener {
|
|
static const int _maxQueryCount = 3;
|
|
final HashMap<String, String> _emptyMessages = HashMap.from({
|
|
LoadEvent.recent: 'empty_recent_tip',
|
|
LoadEvent.favorite: 'empty_favorite_tip',
|
|
LoadEvent.lan: 'empty_lan_tip',
|
|
LoadEvent.addressBook: 'empty_address_book_tip',
|
|
});
|
|
final space = isDesktop ? 12.0 : 8.0;
|
|
final _curPeers = <String>{};
|
|
var _lastChangeTime = DateTime.now();
|
|
var _lastQueryPeers = <String>{};
|
|
var _lastQueryTime = DateTime.now().add(const Duration(seconds: 30));
|
|
var _queryCount = 0;
|
|
var _exit = false;
|
|
|
|
late final mobileWidth = () {
|
|
const minWidth = 320.0;
|
|
final windowWidth = MediaQuery.of(context).size.width;
|
|
var width = windowWidth - 2 * space;
|
|
if (windowWidth > minWidth + 2 * space) {
|
|
final n = (windowWidth / (minWidth + 2 * space)).floor();
|
|
width = windowWidth / n - 2 * space;
|
|
}
|
|
return width;
|
|
}();
|
|
|
|
final _scrollController = ScrollController();
|
|
|
|
_PeersViewState() {
|
|
_startCheckOnlines();
|
|
}
|
|
|
|
@override
|
|
void initState() {
|
|
windowManager.addListener(this);
|
|
super.initState();
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
windowManager.removeListener(this);
|
|
_exit = true;
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
void onWindowFocus() {
|
|
_queryCount = 0;
|
|
}
|
|
|
|
@override
|
|
void onWindowMinimize() {
|
|
_queryCount = _maxQueryCount;
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return ChangeNotifierProvider<Peers>(
|
|
create: (context) => widget.peers,
|
|
child: Consumer<Peers>(builder: (context, peers, child) {
|
|
if (peers.peers.isEmpty) {
|
|
gFFI.peerTabModel.setCurrentTabCachedPeers([]);
|
|
return Center(
|
|
child: Column(
|
|
mainAxisAlignment: MainAxisAlignment.center,
|
|
children: [
|
|
Icon(
|
|
Icons.sentiment_very_dissatisfied_rounded,
|
|
color: Theme.of(context).tabBarTheme.labelColor,
|
|
size: 40,
|
|
).paddingOnly(bottom: 10),
|
|
Text(
|
|
translate(
|
|
_emptyMessages[widget.peers.loadEvent] ?? 'Empty',
|
|
),
|
|
textAlign: TextAlign.center,
|
|
style: TextStyle(
|
|
color: Theme.of(context).tabBarTheme.labelColor,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
} else {
|
|
return _buildPeersView(peers);
|
|
}
|
|
}),
|
|
);
|
|
}
|
|
|
|
onVisibilityChanged(VisibilityInfo info) {
|
|
final peerId = _peerId((info.key as ValueKey).value);
|
|
if (info.visibleFraction > 0.00001) {
|
|
_curPeers.add(peerId);
|
|
} else {
|
|
_curPeers.remove(peerId);
|
|
}
|
|
_lastChangeTime = DateTime.now();
|
|
}
|
|
|
|
String _cardId(String id) => widget.peers.name + id;
|
|
String _peerId(String cardId) => cardId.replaceAll(widget.peers.name, '');
|
|
|
|
Widget _buildPeersView(Peers peers) {
|
|
final updateEvent = peers.event;
|
|
final body = ObxValue<RxList>((filters) {
|
|
return FutureBuilder<List<Peer>>(
|
|
builder: (context, snapshot) {
|
|
if (snapshot.hasData) {
|
|
var peers = snapshot.data!;
|
|
if (peers.length > 1000) peers = peers.sublist(0, 1000);
|
|
gFFI.peerTabModel.setCurrentTabCachedPeers(peers);
|
|
buildOnePeer(Peer peer) {
|
|
final visibilityChild = VisibilityDetector(
|
|
key: ValueKey(_cardId(peer.id)),
|
|
onVisibilityChanged: onVisibilityChanged,
|
|
child: widget.peerCardBuilder(peer),
|
|
);
|
|
final windowWidth = MediaQuery.of(context).size.width;
|
|
// `Provider.of<PeerTabModel>(context)` will causes infinete loop.
|
|
// Because `gFFI.peerTabModel.setCurrentTabCachedPeers(peers)` will trigger `notifyListeners()`.
|
|
//
|
|
// No need to listen the currentTab change event.
|
|
// Because the currentTab change event will trigger the peers change event,
|
|
// and the peers change event will trigger _buildPeersView().
|
|
final currentTab =
|
|
Provider.of<PeerTabModel>(context, listen: false).currentTab;
|
|
final hideAbTagsPanel =
|
|
bind.mainGetLocalOption(key: "hideAbTagsPanel").isNotEmpty;
|
|
return isDesktop
|
|
? Obx(
|
|
() => SizedBox(
|
|
width: peerCardUiType.value != PeerUiType.list
|
|
? 220
|
|
: currentTab == PeerTabIndex.group.index ||
|
|
(currentTab == PeerTabIndex.ab.index &&
|
|
!hideAbTagsPanel)
|
|
? windowWidth - 390
|
|
: windowWidth - 227,
|
|
height: peerCardUiType.value == PeerUiType.grid
|
|
? 140
|
|
: peerCardUiType.value != PeerUiType.list
|
|
? 42
|
|
: 45,
|
|
child: visibilityChild,
|
|
),
|
|
)
|
|
: SizedBox(width: mobileWidth, child: visibilityChild);
|
|
}
|
|
|
|
final Widget child;
|
|
if (isMobile) {
|
|
child = DynamicGridView.builder(
|
|
gridDelegate: SliverGridDelegateWithWrapping(
|
|
mainAxisSpacing: space / 2, crossAxisSpacing: space),
|
|
itemCount: peers.length,
|
|
itemBuilder: (BuildContext context, int index) {
|
|
return buildOnePeer(peers[index]);
|
|
},
|
|
);
|
|
} else {
|
|
child = DesktopScrollWrapper(
|
|
scrollController: _scrollController,
|
|
child: DynamicGridView.builder(
|
|
controller: _scrollController,
|
|
physics: DraggableNeverScrollableScrollPhysics(),
|
|
gridDelegate: SliverGridDelegateWithWrapping(
|
|
mainAxisSpacing: space / 2, crossAxisSpacing: space),
|
|
itemCount: peers.length,
|
|
itemBuilder: (BuildContext context, int index) {
|
|
return buildOnePeer(peers[index]);
|
|
}),
|
|
);
|
|
}
|
|
|
|
if (updateEvent == UpdateEvent.load) {
|
|
_curPeers.clear();
|
|
_curPeers.addAll(peers.map((e) => e.id));
|
|
_queryOnlines(true);
|
|
}
|
|
return child;
|
|
} else {
|
|
return const Center(
|
|
child: CircularProgressIndicator(),
|
|
);
|
|
}
|
|
},
|
|
future: matchPeers(filters[0].value, filters[1].value, peers.peers),
|
|
);
|
|
}, obslist);
|
|
|
|
return body;
|
|
}
|
|
|
|
final _queryInterval = const Duration(seconds: 20);
|
|
|
|
void _startCheckOnlines() {
|
|
() async {
|
|
while (!_exit) {
|
|
final now = DateTime.now();
|
|
if (!setEquals(_curPeers, _lastQueryPeers)) {
|
|
if (now.difference(_lastChangeTime) > const Duration(seconds: 1)) {
|
|
_queryOnlines(false);
|
|
}
|
|
} else {
|
|
if (_queryCount < _maxQueryCount) {
|
|
if (now.difference(_lastQueryTime) >= _queryInterval) {
|
|
if (_curPeers.isNotEmpty) {
|
|
bind.queryOnlines(ids: _curPeers.toList(growable: false));
|
|
_lastQueryTime = DateTime.now();
|
|
_queryCount += 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
await Future.delayed(const Duration(milliseconds: 300));
|
|
}
|
|
}();
|
|
}
|
|
|
|
_queryOnlines(bool isLoadEvent) {
|
|
if (_curPeers.isNotEmpty) {
|
|
bind.queryOnlines(ids: _curPeers.toList(growable: false));
|
|
_lastQueryPeers = {..._curPeers};
|
|
if (isLoadEvent) {
|
|
_lastChangeTime = DateTime.now();
|
|
} else {
|
|
_lastQueryTime = DateTime.now().subtract(_queryInterval);
|
|
}
|
|
_queryCount = 0;
|
|
}
|
|
}
|
|
|
|
Future<List<Peer>>? matchPeers(
|
|
String searchText, String sortedBy, List<Peer> peers) async {
|
|
if (widget.peerFilter != null) {
|
|
peers = peers.where((peer) => widget.peerFilter!(peer)).toList();
|
|
}
|
|
|
|
// fallback to id sorting
|
|
if (!PeerSortType.values.contains(sortedBy)) {
|
|
sortedBy = PeerSortType.remoteId;
|
|
bind.setLocalFlutterOption(
|
|
k: "peer-sorting",
|
|
v: sortedBy,
|
|
);
|
|
}
|
|
|
|
if (widget.peers.loadEvent != LoadEvent.recent) {
|
|
switch (sortedBy) {
|
|
case PeerSortType.remoteId:
|
|
peers.sort((p1, p2) => p1.getId().compareTo(p2.getId()));
|
|
break;
|
|
case PeerSortType.remoteHost:
|
|
peers.sort((p1, p2) =>
|
|
p1.hostname.toLowerCase().compareTo(p2.hostname.toLowerCase()));
|
|
break;
|
|
case PeerSortType.username:
|
|
peers.sort((p1, p2) =>
|
|
p1.username.toLowerCase().compareTo(p2.username.toLowerCase()));
|
|
break;
|
|
// case PeerSortType.status:
|
|
// peers.sort((p1, p2) => p1.online ? -1 : 1);
|
|
// break;
|
|
}
|
|
}
|
|
|
|
searchText = searchText.trim();
|
|
if (searchText.isEmpty) {
|
|
return peers;
|
|
}
|
|
searchText = searchText.toLowerCase();
|
|
final matches =
|
|
await Future.wait(peers.map((peer) => matchPeer(searchText, peer)));
|
|
final filteredList = List<Peer>.empty(growable: true);
|
|
for (var i = 0; i < peers.length; i++) {
|
|
if (matches[i]) {
|
|
filteredList.add(peers[i]);
|
|
}
|
|
}
|
|
|
|
return filteredList;
|
|
}
|
|
}
|
|
|
|
abstract class BasePeersView extends StatelessWidget {
|
|
final String name;
|
|
final String loadEvent;
|
|
final PeerFilter? peerFilter;
|
|
final PeerCardBuilder peerCardBuilder;
|
|
final GetInitPeers? getInitPeers;
|
|
|
|
const BasePeersView({
|
|
Key? key,
|
|
required this.name,
|
|
required this.loadEvent,
|
|
this.peerFilter,
|
|
required this.peerCardBuilder,
|
|
required this.getInitPeers,
|
|
}) : super(key: key);
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return _PeersView(
|
|
peers:
|
|
Peers(name: name, loadEvent: loadEvent, getInitPeers: getInitPeers),
|
|
peerFilter: peerFilter,
|
|
peerCardBuilder: peerCardBuilder);
|
|
}
|
|
}
|
|
|
|
class RecentPeersView extends BasePeersView {
|
|
RecentPeersView(
|
|
{Key? key, EdgeInsets? menuPadding, ScrollController? scrollController})
|
|
: super(
|
|
key: key,
|
|
name: 'recent peer',
|
|
loadEvent: LoadEvent.recent,
|
|
peerCardBuilder: (Peer peer) => RecentPeerCard(
|
|
peer: peer,
|
|
menuPadding: menuPadding,
|
|
),
|
|
getInitPeers: null,
|
|
);
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final widget = super.build(context);
|
|
bind.mainLoadRecentPeers();
|
|
return widget;
|
|
}
|
|
}
|
|
|
|
class FavoritePeersView extends BasePeersView {
|
|
FavoritePeersView(
|
|
{Key? key, EdgeInsets? menuPadding, ScrollController? scrollController})
|
|
: super(
|
|
key: key,
|
|
name: 'favorite peer',
|
|
loadEvent: LoadEvent.favorite,
|
|
peerCardBuilder: (Peer peer) => FavoritePeerCard(
|
|
peer: peer,
|
|
menuPadding: menuPadding,
|
|
),
|
|
getInitPeers: null,
|
|
);
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final widget = super.build(context);
|
|
bind.mainLoadFavPeers();
|
|
return widget;
|
|
}
|
|
}
|
|
|
|
class DiscoveredPeersView extends BasePeersView {
|
|
DiscoveredPeersView(
|
|
{Key? key, EdgeInsets? menuPadding, ScrollController? scrollController})
|
|
: super(
|
|
key: key,
|
|
name: 'discovered peer',
|
|
loadEvent: LoadEvent.lan,
|
|
peerCardBuilder: (Peer peer) => DiscoveredPeerCard(
|
|
peer: peer,
|
|
menuPadding: menuPadding,
|
|
),
|
|
getInitPeers: null,
|
|
);
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final widget = super.build(context);
|
|
bind.mainLoadLanPeers();
|
|
return widget;
|
|
}
|
|
}
|
|
|
|
class AddressBookPeersView extends BasePeersView {
|
|
AddressBookPeersView(
|
|
{Key? key,
|
|
EdgeInsets? menuPadding,
|
|
ScrollController? scrollController,
|
|
required GetInitPeers getInitPeers})
|
|
: super(
|
|
key: key,
|
|
name: 'address book peer',
|
|
loadEvent: LoadEvent.addressBook,
|
|
peerFilter: (Peer peer) =>
|
|
_hitTag(gFFI.abModel.selectedTags, peer.tags),
|
|
peerCardBuilder: (Peer peer) => AddressBookPeerCard(
|
|
peer: peer,
|
|
menuPadding: menuPadding,
|
|
),
|
|
getInitPeers: getInitPeers,
|
|
);
|
|
|
|
static bool _hitTag(List<dynamic> selectedTags, List<dynamic> idents) {
|
|
if (selectedTags.isEmpty) {
|
|
return true;
|
|
}
|
|
if (gFFI.abModel.filterByIntersection.value) {
|
|
for (final tag in selectedTags) {
|
|
if (!idents.contains(tag)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
} else {
|
|
for (final tag in selectedTags) {
|
|
if (idents.contains(tag)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
class MyGroupPeerView extends BasePeersView {
|
|
MyGroupPeerView(
|
|
{Key? key,
|
|
EdgeInsets? menuPadding,
|
|
ScrollController? scrollController,
|
|
required GetInitPeers getInitPeers})
|
|
: super(
|
|
key: key,
|
|
name: 'group peer',
|
|
loadEvent: LoadEvent.group,
|
|
peerFilter: filter,
|
|
peerCardBuilder: (Peer peer) => MyGroupPeerCard(
|
|
peer: peer,
|
|
menuPadding: menuPadding,
|
|
),
|
|
getInitPeers: getInitPeers,
|
|
);
|
|
|
|
static bool filter(Peer peer) {
|
|
if (gFFI.groupModel.searchUserText.isNotEmpty) {
|
|
if (!peer.loginName.contains(gFFI.groupModel.searchUserText)) {
|
|
return false;
|
|
}
|
|
}
|
|
if (gFFI.groupModel.selectedUser.isNotEmpty) {
|
|
if (gFFI.groupModel.selectedUser.value != peer.loginName) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|