vjrj
97b9223cb2
Discovery searched the full 5-char geohash (~2.4 km) with an exact Nostr tag match, so two devices in adjacent cells never found each other even though publish emits the full NIP-52 prefix ladder. Search now coarsens the area to a configurable precision (SocialSettings.searchPrecision, default 4 ~20 km) via searchPrefix(), with a human-worded 'how far' selector (Very close / Around here / My region -> 5/4/3) in the market setup sheet. Also: surface a clear 'couldn't reach the servers' message when no relay accepts a share (instead of 'shared 0'), and add wss://relay.comunes.org as the first default relay (reliable community home; public relays are backup). Tests: settings precision (default/clamp/roundtrip), searchPrefix helper, neighbour-cell discovery regression (offers_cubit + commons_core nostr transports), and the range-selector widget test.
740 lines
25 KiB
Dart
740 lines
25 KiB
Dart
import 'package:commons_core/commons_core.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:flutter_bloc/flutter_bloc.dart';
|
|
import 'package:go_router/go_router.dart';
|
|
|
|
import '../data/variety_repository.dart';
|
|
import '../i18n/strings.g.dart';
|
|
import '../services/coarse_location.dart';
|
|
import '../services/discovery_area.dart';
|
|
import '../services/offer_outbox.dart';
|
|
import '../services/social_service.dart';
|
|
import '../services/social_settings.dart';
|
|
import '../state/offers_cubit.dart';
|
|
import 'theme.dart';
|
|
|
|
/// The market (redesign screens 04/05): discover seeds shared near you. Opens
|
|
/// an offer transport lazily; local-first, so it degrades to a "set up sharing"
|
|
/// prompt when no relay/area is configured or the network is unreachable.
|
|
class MarketScreen extends StatefulWidget {
|
|
const MarketScreen({
|
|
required this.social,
|
|
required this.settings,
|
|
this.location,
|
|
this.outbox,
|
|
super.key,
|
|
});
|
|
|
|
final SocialService social;
|
|
final SocialSettings settings;
|
|
|
|
/// Optional device-location source for the "use my location" shortcut; when
|
|
/// null (tests, or a platform without it) the shortcut is hidden.
|
|
final CoarseLocationProvider? location;
|
|
|
|
/// Optional offline outbox: parks shares attempted with no network and flushes
|
|
/// them on reconnect. Null in tests → sharing offline is simply a no-op.
|
|
final OfferOutbox? outbox;
|
|
|
|
@override
|
|
State<MarketScreen> createState() => _MarketScreenState();
|
|
}
|
|
|
|
class _MarketScreenState extends State<MarketScreen> {
|
|
OffersCubit? _cubit;
|
|
bool _loading = true;
|
|
bool _hasArea = false;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_init();
|
|
}
|
|
|
|
Future<void> _init() async {
|
|
// Only needed to flush the outbox; read here (while mounted) to avoid using
|
|
// context across the awaits below. Null when there's no outbox (e.g. tests).
|
|
final repo =
|
|
widget.outbox != null ? context.read<VarietyRepository>() : null;
|
|
setState(() => _loading = true);
|
|
final cubit = await createOffersCubit(widget.social, widget.settings);
|
|
final area = await widget.settings.areaGeohash();
|
|
if (!mounted) {
|
|
await cubit.close();
|
|
return;
|
|
}
|
|
final previous = _cubit;
|
|
setState(() {
|
|
_cubit = cubit;
|
|
_hasArea = area.isNotEmpty;
|
|
_loading = false;
|
|
});
|
|
await previous?.close();
|
|
if (area.isNotEmpty && cubit.isOnline) {
|
|
// Flush anything parked while offline, then show what's out there.
|
|
final outbox = widget.outbox;
|
|
if (outbox != null && repo != null) {
|
|
await flushOutbox(
|
|
outbox: outbox,
|
|
cubit: cubit,
|
|
shareableLots: await repo.shareableLots(),
|
|
authorPubkeyHex: widget.social.publicKeyHex,
|
|
areaGeohash: area,
|
|
);
|
|
}
|
|
if (mounted) {
|
|
final precision = await widget.settings.searchPrecision();
|
|
if (mounted) await cubit.discover(searchPrefix(area, precision));
|
|
}
|
|
}
|
|
}
|
|
|
|
Future<void> _openConfig() async {
|
|
final changed = await showModalBottomSheet<bool>(
|
|
context: context,
|
|
isScrollControlled: true,
|
|
builder: (_) =>
|
|
_ConfigSheet(settings: widget.settings, location: widget.location),
|
|
);
|
|
if (changed == true) await _init();
|
|
}
|
|
|
|
/// Publishes the user's shared lots as offers to the network, tagged with the
|
|
/// coarse area. Prompts for setup when the area isn't set.
|
|
Future<void> _shareMine() async {
|
|
final cubit = _cubit;
|
|
if (cubit == null) return;
|
|
final repo = context.read<VarietyRepository>();
|
|
final messenger = ScaffoldMessenger.of(context);
|
|
final t = context.t;
|
|
final area = await widget.settings.areaGeohash();
|
|
if (!mounted) return;
|
|
if (area.isEmpty) {
|
|
await _openConfig();
|
|
return;
|
|
}
|
|
final lots = await repo.shareableLots();
|
|
if (!mounted) return;
|
|
if (lots.isEmpty) {
|
|
messenger.showSnackBar(SnackBar(content: Text(t.market.nothingToShare)));
|
|
return;
|
|
}
|
|
final ids = lots.map((l) => l.lotId).toList();
|
|
|
|
// Offline: park it and tell the person we'll share it later.
|
|
if (!cubit.isOnline) {
|
|
await widget.outbox?.enqueue(ids);
|
|
if (!mounted) return;
|
|
messenger.showSnackBar(SnackBar(content: Text(t.market.queued)));
|
|
return;
|
|
}
|
|
|
|
final count = await cubit.publishLots(
|
|
lots,
|
|
authorPubkeyHex: widget.social.publicKeyHex,
|
|
areaGeohash: area,
|
|
);
|
|
if (!mounted) return;
|
|
await widget.outbox?.remove(ids); // published now, so unpark any duplicates
|
|
// count == 0 with lots to share means every relay refused — say so plainly
|
|
// rather than "shared 0", which reads like success.
|
|
messenger.showSnackBar(SnackBar(
|
|
content: Text(count == 0 ? t.market.shareFailed : t.market.sharedCount(n: count)),
|
|
));
|
|
final precision = await widget.settings.searchPrecision();
|
|
if (!mounted) return;
|
|
await cubit.discover(searchPrefix(area, precision)); // refresh incl. just-shared
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_cubit?.close();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final t = context.t;
|
|
final cubit = _cubit;
|
|
return Scaffold(
|
|
appBar: AppBar(
|
|
title: Text(t.market.title),
|
|
actions: [
|
|
IconButton(
|
|
key: const Key('market.config'),
|
|
icon: const Icon(Icons.tune),
|
|
tooltip: t.market.configTitle,
|
|
onPressed: _openConfig,
|
|
),
|
|
],
|
|
),
|
|
floatingActionButton:
|
|
cubit != null && (cubit.isOnline || widget.outbox != null)
|
|
? FloatingActionButton.extended(
|
|
key: const Key('market.shareMine'),
|
|
onPressed: _shareMine,
|
|
icon: const Icon(Icons.campaign_outlined),
|
|
label: Text(t.market.shareMine),
|
|
)
|
|
: null,
|
|
body: _loading || cubit == null
|
|
? const Center(child: CircularProgressIndicator())
|
|
: BlocProvider.value(
|
|
value: cubit,
|
|
child: MarketBody(
|
|
onConfigure: _openConfig,
|
|
onRetry: _init,
|
|
hasArea: _hasArea,
|
|
selfPubkey: widget.social.publicKeyHex,
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class MarketBody extends StatelessWidget {
|
|
const MarketBody({
|
|
required this.onConfigure,
|
|
this.onRetry,
|
|
this.hasArea = true,
|
|
this.selfPubkey,
|
|
super.key,
|
|
});
|
|
|
|
final VoidCallback onConfigure;
|
|
|
|
/// Re-opens the connection (for the "can't reach servers" retry).
|
|
final VoidCallback? onRetry;
|
|
|
|
/// Whether the user has set their coarse area yet.
|
|
final bool hasArea;
|
|
|
|
/// This user's own pubkey, so we don't offer to message our own listings.
|
|
final String? selfPubkey;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final t = context.t;
|
|
return BlocBuilder<OffersCubit, OffersState>(
|
|
builder: (context, state) {
|
|
if (!context.read<OffersCubit>().isOnline) {
|
|
// Default community servers exist, so "offline" means unreachable —
|
|
// offer a retry rather than "set up sharing".
|
|
return _EmptyState(
|
|
icon: Icons.wifi_tethering_off_outlined,
|
|
title: t.market.cantReach,
|
|
body: t.market.cantReachBody,
|
|
actionLabel: onRetry != null ? t.market.retry : null,
|
|
onAction: onRetry,
|
|
);
|
|
}
|
|
if (!hasArea) {
|
|
return _EmptyState(
|
|
icon: Icons.place_outlined,
|
|
title: t.market.setArea,
|
|
body: t.market.setAreaBody,
|
|
actionLabel: t.market.setUp,
|
|
onAction: onConfigure,
|
|
);
|
|
}
|
|
if (state.searching && state.offers.isEmpty) {
|
|
return Center(
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
const CircularProgressIndicator(),
|
|
const SizedBox(height: 16),
|
|
Text(t.market.searching,
|
|
style: const TextStyle(color: seedMuted)),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
final cubit = context.read<OffersCubit>();
|
|
// Pull-to-refresh re-runs discovery for the current area (keeping the
|
|
// text filter), so the list is never stuck on a stale scan.
|
|
Future<void> refresh() => cubit.discover(state.areaGeohash);
|
|
|
|
// Nothing discovered at all: keep the friendly empty state, but make it
|
|
// pull-to-refreshable so a swipe re-scans.
|
|
if (state.offers.isEmpty) {
|
|
return RefreshIndicator(
|
|
onRefresh: refresh,
|
|
child: ListView(
|
|
// AlwaysScrollable so the pull gesture works with a single child.
|
|
physics: const AlwaysScrollableScrollPhysics(),
|
|
children: [
|
|
SizedBox(
|
|
height: MediaQuery.of(context).size.height * 0.6,
|
|
child: _EmptyState(
|
|
icon: Icons.grass_outlined,
|
|
title: t.market.empty,
|
|
body: '',
|
|
),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
final visible = state.visibleOffers;
|
|
return Column(
|
|
children: [
|
|
Padding(
|
|
padding: const EdgeInsets.fromLTRB(12, 12, 12, 4),
|
|
child: TextField(
|
|
key: const Key('market.search'),
|
|
decoration: InputDecoration(
|
|
hintText: t.market.searchHint,
|
|
prefixIcon: const Icon(Icons.search, color: seedMuted),
|
|
hintStyle: const TextStyle(color: seedMuted),
|
|
filled: true,
|
|
fillColor: Colors.white,
|
|
isDense: true,
|
|
contentPadding: const EdgeInsets.symmetric(vertical: 14),
|
|
border: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(28),
|
|
borderSide: BorderSide.none,
|
|
),
|
|
),
|
|
onChanged: cubit.search,
|
|
),
|
|
),
|
|
Expanded(
|
|
child: RefreshIndicator(
|
|
onRefresh: refresh,
|
|
child: visible.isEmpty
|
|
// Discovered offers exist, but the search filtered them out.
|
|
? ListView(
|
|
physics: const AlwaysScrollableScrollPhysics(),
|
|
children: [
|
|
SizedBox(
|
|
height: MediaQuery.of(context).size.height * 0.5,
|
|
child: _EmptyState(
|
|
icon: Icons.search_off,
|
|
title: t.market.noMatches,
|
|
body: '',
|
|
),
|
|
),
|
|
],
|
|
)
|
|
: ListView.separated(
|
|
physics: const AlwaysScrollableScrollPhysics(),
|
|
padding: const EdgeInsets.all(16),
|
|
itemCount: visible.length,
|
|
separatorBuilder: (_, _) => const SizedBox(height: 12),
|
|
itemBuilder: (context, i) {
|
|
final o = visible[i];
|
|
final mine = o.authorPubkeyHex == selfPubkey;
|
|
return _OfferCard(
|
|
offer: o,
|
|
mine: mine,
|
|
onContact: mine
|
|
? null
|
|
: () =>
|
|
context.push('/chat/${o.authorPubkeyHex}'),
|
|
);
|
|
},
|
|
),
|
|
),
|
|
),
|
|
],
|
|
);
|
|
},
|
|
);
|
|
}
|
|
}
|
|
|
|
/// One discovered offer. Human words for the reciprocity mode; coarse "near you"
|
|
/// instead of any precise location; price only when it's a sale.
|
|
class _OfferCard extends StatelessWidget {
|
|
const _OfferCard({required this.offer, this.mine = false, this.onContact});
|
|
|
|
final Offer offer;
|
|
|
|
/// Whether this is the current user's own listing (shown with a "You" badge).
|
|
final bool mine;
|
|
|
|
/// Opens a private chat with the author; null for our own listings.
|
|
final VoidCallback? onContact;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final t = context.t;
|
|
return Container(
|
|
decoration: BoxDecoration(
|
|
color: Colors.white,
|
|
borderRadius: BorderRadius.circular(14),
|
|
border: Border.all(color: seedOutline),
|
|
),
|
|
padding: const EdgeInsets.all(16),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: Text(
|
|
offer.summary,
|
|
style: const TextStyle(
|
|
fontSize: 17,
|
|
fontWeight: FontWeight.w500,
|
|
color: seedOnSurface,
|
|
),
|
|
),
|
|
),
|
|
if (mine) ...[
|
|
Container(
|
|
padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 3),
|
|
decoration: BoxDecoration(
|
|
color: seedGreen,
|
|
borderRadius: BorderRadius.circular(20),
|
|
),
|
|
child: Text(
|
|
t.market.mine,
|
|
style: const TextStyle(
|
|
color: Colors.white,
|
|
fontSize: 11,
|
|
fontWeight: FontWeight.w700,
|
|
),
|
|
),
|
|
),
|
|
const SizedBox(width: 6),
|
|
],
|
|
_TypeChip(label: _offerTypeLabel(t, offer.type)),
|
|
],
|
|
),
|
|
const SizedBox(height: 6),
|
|
Row(
|
|
children: [
|
|
const Icon(Icons.place_outlined, size: 15, color: seedMuted),
|
|
const SizedBox(width: 4),
|
|
Text(t.market.near, style: const TextStyle(color: seedMuted, fontSize: 13)),
|
|
const Spacer(),
|
|
if (offer.type == OfferType.sale && offer.priceAmount != null)
|
|
Text(
|
|
'${offer.priceAmount} ${offer.priceCurrency ?? ''}'.trim(),
|
|
style: const TextStyle(
|
|
color: seedOnSurface,
|
|
fontWeight: FontWeight.w600,
|
|
),
|
|
),
|
|
if (onContact != null)
|
|
TextButton.icon(
|
|
onPressed: onContact,
|
|
icon: const Icon(Icons.chat_bubble_outline, size: 16),
|
|
label: Text(t.market.contact),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
String _offerTypeLabel(Translations t, OfferType type) => switch (type) {
|
|
OfferType.gift => t.share.gift,
|
|
OfferType.exchange => t.share.exchange,
|
|
OfferType.sale => t.share.sell,
|
|
OfferType.wanted => t.market.wanted,
|
|
OfferType.lend => t.share.exchange,
|
|
};
|
|
|
|
class _TypeChip extends StatelessWidget {
|
|
const _TypeChip({required this.label});
|
|
|
|
final String label;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Container(
|
|
padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 4),
|
|
decoration: BoxDecoration(
|
|
color: seedPrimaryContainer,
|
|
borderRadius: BorderRadius.circular(20),
|
|
),
|
|
child: Text(
|
|
label,
|
|
style: const TextStyle(
|
|
color: seedOnPrimaryContainer,
|
|
fontSize: 12,
|
|
fontWeight: FontWeight.w600,
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
class _EmptyState extends StatelessWidget {
|
|
const _EmptyState({
|
|
required this.icon,
|
|
required this.title,
|
|
required this.body,
|
|
this.actionLabel,
|
|
this.onAction,
|
|
});
|
|
|
|
final IconData icon;
|
|
final String title;
|
|
final String body;
|
|
final String? actionLabel;
|
|
final VoidCallback? onAction;
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Center(
|
|
child: Padding(
|
|
padding: const EdgeInsets.all(32),
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
children: [
|
|
Icon(icon, size: 56, color: seedMuted),
|
|
const SizedBox(height: 16),
|
|
Text(
|
|
title,
|
|
textAlign: TextAlign.center,
|
|
style: const TextStyle(
|
|
fontSize: 18,
|
|
fontWeight: FontWeight.w500,
|
|
color: seedOnSurface,
|
|
),
|
|
),
|
|
if (body.isNotEmpty) ...[
|
|
const SizedBox(height: 8),
|
|
Text(
|
|
body,
|
|
textAlign: TextAlign.center,
|
|
style: const TextStyle(color: seedMuted, fontSize: 14),
|
|
),
|
|
],
|
|
if (actionLabel != null && onAction != null) ...[
|
|
const SizedBox(height: 20),
|
|
FilledButton(onPressed: onAction, child: Text(actionLabel!)),
|
|
],
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Coarse-area + community-server setup. Kept behind progressive disclosure — a
|
|
/// power-user surface — with human-worded labels.
|
|
class _ConfigSheet extends StatefulWidget {
|
|
const _ConfigSheet({required this.settings, this.location});
|
|
|
|
final SocialSettings settings;
|
|
final CoarseLocationProvider? location;
|
|
|
|
@override
|
|
State<_ConfigSheet> createState() => _ConfigSheetState();
|
|
}
|
|
|
|
class _ConfigSheetState extends State<_ConfigSheet> {
|
|
final _area = TextEditingController();
|
|
final _servers = TextEditingController();
|
|
bool _loading = true;
|
|
bool _locationBusy = false;
|
|
String? _locationError;
|
|
int _precision = SocialSettings.defaultSearchPrecision;
|
|
|
|
@override
|
|
void initState() {
|
|
super.initState();
|
|
_load();
|
|
}
|
|
|
|
Future<void> _load() async {
|
|
_area.text = await widget.settings.areaGeohash();
|
|
_servers.text = (await widget.settings.relayUrls()).join('\n');
|
|
_precision = await widget.settings.searchPrecision();
|
|
if (mounted) setState(() => _loading = false);
|
|
}
|
|
|
|
Future<void> _save() async {
|
|
await widget.settings.setAreaGeohash(_area.text);
|
|
await widget.settings.setRelayUrls(_servers.text.split('\n'));
|
|
await widget.settings.setSearchPrecision(_precision);
|
|
if (mounted) Navigator.of(context).pop(true);
|
|
}
|
|
|
|
/// Fills the area from the device's approximate location, reduced to a coarse
|
|
/// geohash so no precise fix is stored.
|
|
Future<void> _useLocation() async {
|
|
final provider = widget.location;
|
|
if (provider == null || _locationBusy) return;
|
|
setState(() {
|
|
_locationBusy = true;
|
|
_locationError = null;
|
|
});
|
|
final loc = await provider.currentCoarseLatLon();
|
|
if (!mounted) return;
|
|
setState(() {
|
|
_locationBusy = false;
|
|
if (loc == null) {
|
|
_locationError = context.t.market.locationFailed;
|
|
} else {
|
|
_area.text = Geohash.encode(loc.lat, loc.lon, precision: 5);
|
|
}
|
|
});
|
|
}
|
|
|
|
@override
|
|
void dispose() {
|
|
_area.dispose();
|
|
_servers.dispose();
|
|
super.dispose();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
final t = context.t;
|
|
final hasArea = _area.text.trim().isNotEmpty;
|
|
return Padding(
|
|
padding: EdgeInsets.only(
|
|
left: 20,
|
|
right: 20,
|
|
top: 20,
|
|
bottom: MediaQuery.of(context).viewInsets.bottom + 20,
|
|
),
|
|
child: _loading
|
|
? const SizedBox(
|
|
height: 120, child: Center(child: CircularProgressIndicator()))
|
|
: SingleChildScrollView(
|
|
child: Column(
|
|
mainAxisSize: MainAxisSize.min,
|
|
crossAxisAlignment: CrossAxisAlignment.stretch,
|
|
children: [
|
|
Text(
|
|
t.market.configTitle,
|
|
style: const TextStyle(
|
|
fontSize: 18,
|
|
fontWeight: FontWeight.w600,
|
|
color: seedTitle,
|
|
),
|
|
),
|
|
const SizedBox(height: 8),
|
|
Text(
|
|
t.market.setupIntro,
|
|
style: const TextStyle(
|
|
color: seedMuted, fontSize: 13, height: 1.4),
|
|
),
|
|
const SizedBox(height: 18),
|
|
// Setting your area from device location is the human path;
|
|
// typing a code is the advanced fallback.
|
|
if (widget.location != null)
|
|
FilledButton.tonalIcon(
|
|
key: const Key('market.useLocation'),
|
|
onPressed: _locationBusy ? null : _useLocation,
|
|
icon: _locationBusy
|
|
? const SizedBox(
|
|
width: 16,
|
|
height: 16,
|
|
child: CircularProgressIndicator(strokeWidth: 2),
|
|
)
|
|
: const Icon(Icons.my_location, size: 18),
|
|
label: Text(t.market.useLocation),
|
|
),
|
|
if (_locationError != null)
|
|
Padding(
|
|
padding: const EdgeInsets.only(top: 6),
|
|
child: Text(
|
|
_locationError!,
|
|
style: const TextStyle(
|
|
color: Color(0xFFB3261E), fontSize: 12),
|
|
),
|
|
),
|
|
const SizedBox(height: 12),
|
|
Row(
|
|
children: [
|
|
Icon(
|
|
hasArea
|
|
? Icons.check_circle
|
|
: Icons.pending_outlined,
|
|
size: 18,
|
|
color: hasArea ? seedGreen : seedMuted,
|
|
),
|
|
const SizedBox(width: 8),
|
|
Expanded(
|
|
child: Text(
|
|
hasArea ? t.market.areaSet : t.market.areaNotSet,
|
|
style: TextStyle(
|
|
color: hasArea ? seedOnSurface : seedMuted,
|
|
fontSize: 13,
|
|
),
|
|
),
|
|
),
|
|
],
|
|
),
|
|
const SizedBox(height: 16),
|
|
Align(
|
|
alignment: AlignmentDirectional.centerStart,
|
|
child: Text(
|
|
t.market.rangeLabel,
|
|
style: const TextStyle(fontSize: 13, color: seedMuted),
|
|
),
|
|
),
|
|
const SizedBox(height: 8),
|
|
SegmentedButton<int>(
|
|
key: const Key('market.range'),
|
|
segments: [
|
|
ButtonSegment(value: 5, label: Text(t.market.rangeNear)),
|
|
ButtonSegment(value: 4, label: Text(t.market.rangeArea)),
|
|
ButtonSegment(value: 3, label: Text(t.market.rangeRegion)),
|
|
],
|
|
selected: {_precision},
|
|
showSelectedIcon: false,
|
|
onSelectionChanged: (s) =>
|
|
setState(() => _precision = s.first),
|
|
),
|
|
const SizedBox(height: 8),
|
|
Theme(
|
|
data: Theme.of(context)
|
|
.copyWith(dividerColor: Colors.transparent),
|
|
child: ExpansionTile(
|
|
key: const Key('market.advanced'),
|
|
tilePadding: EdgeInsets.zero,
|
|
childrenPadding: const EdgeInsets.only(bottom: 8),
|
|
title: Text(
|
|
t.market.advanced,
|
|
style: const TextStyle(fontSize: 13, color: seedMuted),
|
|
),
|
|
children: [
|
|
TextField(
|
|
key: const Key('market.area'),
|
|
controller: _area,
|
|
onChanged: (_) => setState(() {}),
|
|
decoration: InputDecoration(
|
|
labelText: t.market.areaCodeLabel,
|
|
helperText: t.market.areaCodeHint,
|
|
helperMaxLines: 2,
|
|
),
|
|
),
|
|
const SizedBox(height: 14),
|
|
TextField(
|
|
key: const Key('market.servers'),
|
|
controller: _servers,
|
|
minLines: 1,
|
|
maxLines: 3,
|
|
decoration: InputDecoration(
|
|
labelText: t.market.serversLabel,
|
|
helperText: t.market.serversHelp,
|
|
helperMaxLines: 2,
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
const SizedBox(height: 20),
|
|
FilledButton(
|
|
key: const Key('market.save'),
|
|
onPressed: _save,
|
|
child: Text(t.market.save),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
}
|