377 lines
9.8 KiB
Dart
377 lines
9.8 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:flutter_riverpod/flutter_riverpod.dart';
|
|
|
|
import '../../../app/error_message.dart';
|
|
import '../../../app/load_state.dart';
|
|
import '../../../models/ignis_device.dart';
|
|
import '../../../models/ignis_group.dart';
|
|
import '../../../models/ignis_scene.dart';
|
|
import '../../../services/api_client.dart';
|
|
import '../../homes/providers/homes_providers.dart';
|
|
import '../../shared/providers/core_providers.dart';
|
|
|
|
final groupsProvider = NotifierProvider<GroupsNotifier, List<IgnisGroup>>(
|
|
() => GroupsNotifier(),
|
|
);
|
|
|
|
enum GroupsLoadStatus { idle, loading, data, empty, error }
|
|
|
|
class GroupsLoadState {
|
|
final GroupsLoadStatus status;
|
|
final String? errorMessage;
|
|
|
|
const GroupsLoadState._(this.status, {this.errorMessage});
|
|
|
|
const GroupsLoadState.idle() : this._(GroupsLoadStatus.idle);
|
|
|
|
const GroupsLoadState.loading() : this._(GroupsLoadStatus.loading);
|
|
|
|
const GroupsLoadState.data() : this._(GroupsLoadStatus.data);
|
|
|
|
const GroupsLoadState.empty() : this._(GroupsLoadStatus.empty);
|
|
|
|
const GroupsLoadState.error(String message)
|
|
: this._(GroupsLoadStatus.error, errorMessage: message);
|
|
|
|
bool get isLoading => status == GroupsLoadStatus.loading;
|
|
|
|
bool get hasError => status == GroupsLoadStatus.error;
|
|
}
|
|
|
|
final groupsLoadStateProvider =
|
|
NotifierProvider<GroupsLoadStateNotifier, GroupsLoadState>(
|
|
GroupsLoadStateNotifier.new,
|
|
);
|
|
|
|
class GroupsLoadStateNotifier extends Notifier<GroupsLoadState> {
|
|
@override
|
|
GroupsLoadState build() => const GroupsLoadState.idle();
|
|
|
|
void setIdle() => state = const GroupsLoadState.idle();
|
|
|
|
void setLoading() => state = const GroupsLoadState.loading();
|
|
|
|
void setData(List<IgnisGroup> groups) {
|
|
state = groups.isEmpty
|
|
? const GroupsLoadState.empty()
|
|
: const GroupsLoadState.data();
|
|
}
|
|
|
|
void setError(Object error) =>
|
|
state = GroupsLoadState.error(describeLoadError(error));
|
|
}
|
|
|
|
class GroupsNotifier extends Notifier<List<IgnisGroup>> {
|
|
IgnisApi get _api => ref.read(apiProvider);
|
|
Timer? _timer;
|
|
bool _polling = false;
|
|
bool _refreshInFlight = false;
|
|
int? _refreshGeneration;
|
|
int _pollingGeneration = 0;
|
|
String? _pollingHomeId;
|
|
|
|
final Map<String, DateTime> _lockUntil = {};
|
|
final Map<String, Timer> _debounceTimers = {};
|
|
|
|
@override
|
|
List<IgnisGroup> build() {
|
|
ref.onDispose(() {
|
|
_stopPolling(resetStatus: false);
|
|
for (final t in _debounceTimers.values) {
|
|
t.cancel();
|
|
}
|
|
});
|
|
return [];
|
|
}
|
|
|
|
Future<void> startPolling() async {
|
|
final home = ref.read(currentHomeProvider);
|
|
if (home == null) {
|
|
stopPolling();
|
|
return;
|
|
}
|
|
|
|
if (_polling && _pollingHomeId == home.id) {
|
|
return;
|
|
}
|
|
|
|
_stopPolling(resetStatus: false);
|
|
_polling = true;
|
|
_pollingHomeId = home.id;
|
|
final generation = ++_pollingGeneration;
|
|
|
|
final apiKey = await ref
|
|
.read(settingsServiceProvider)
|
|
.requireHomeApiKey(home.id);
|
|
_api.init(home.url, apiKey);
|
|
|
|
await refresh();
|
|
if (!_isActiveGeneration(generation, pollingRequired: true)) return;
|
|
|
|
_timer = Timer.periodic(const Duration(seconds: 10), (_) => refresh());
|
|
}
|
|
|
|
void stopPolling({bool resetStatus = true}) =>
|
|
_stopPolling(resetStatus: resetStatus);
|
|
|
|
void _stopPolling({bool resetStatus = true}) {
|
|
_timer?.cancel();
|
|
_timer = null;
|
|
_polling = false;
|
|
_pollingHomeId = null;
|
|
_pollingGeneration++;
|
|
if (resetStatus) {
|
|
ref.read(groupsLoadStateProvider.notifier).setIdle();
|
|
}
|
|
}
|
|
|
|
Future<void> refresh() async {
|
|
final generation = _pollingGeneration;
|
|
final pollingRequired = _polling;
|
|
if (_refreshInFlight && _refreshGeneration == generation) return;
|
|
|
|
_refreshInFlight = true;
|
|
_refreshGeneration = generation;
|
|
if (state.isEmpty) {
|
|
ref.read(groupsLoadStateProvider.notifier).setLoading();
|
|
}
|
|
|
|
try {
|
|
final resGroups = await _api.getGroups();
|
|
final rawList = IgnisGroup.listFromApi(resGroups.data);
|
|
|
|
final now = DateTime.now();
|
|
final updatedList = await Future.wait(
|
|
rawList.map((group) async {
|
|
if (_lockUntil.containsKey(group.id) &&
|
|
_lockUntil[group.id]!.isAfter(now)) {
|
|
final existing = state.firstWhere(
|
|
(old) => old.id == group.id,
|
|
orElse: () => group,
|
|
);
|
|
return existing;
|
|
}
|
|
|
|
try {
|
|
final resStatus = await _api.getGroupStatus(group.id);
|
|
final groupState = IgnisGroupState.firstFromStatusResponse(
|
|
resStatus.data,
|
|
fallback: group.state,
|
|
);
|
|
return group.copyWith(state: groupState);
|
|
} catch (e) {
|
|
final existing = state.firstWhere(
|
|
(savedGroup) => savedGroup.id == group.id,
|
|
orElse: () => group,
|
|
);
|
|
return group.copyWith(state: existing.state);
|
|
}
|
|
}),
|
|
);
|
|
|
|
if (!_isActiveGeneration(generation, pollingRequired: pollingRequired)) {
|
|
return;
|
|
}
|
|
|
|
state = updatedList;
|
|
ref.read(groupsLoadStateProvider.notifier).setData(updatedList);
|
|
} catch (e) {
|
|
if (_isActiveGeneration(generation, pollingRequired: pollingRequired)) {
|
|
ref.read(groupsLoadStateProvider.notifier).setError(e);
|
|
}
|
|
} finally {
|
|
if (_refreshGeneration == generation) {
|
|
_refreshInFlight = false;
|
|
_refreshGeneration = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool _isActiveGeneration(int generation, {required bool pollingRequired}) =>
|
|
generation == _pollingGeneration && (!pollingRequired || _polling);
|
|
|
|
void _setLock(String id) =>
|
|
_lockUntil[id] = DateTime.now().add(const Duration(seconds: 5));
|
|
|
|
void _updateLocal(String id, Map<String, dynamic> patch) {
|
|
state = [
|
|
for (final g in state)
|
|
if (g.id == id) g.copyWith(state: g.state.applyPatch(patch)) else g,
|
|
];
|
|
}
|
|
|
|
void _debouncedControl(
|
|
String id,
|
|
String key,
|
|
String action,
|
|
Map<String, dynamic> localPatch,
|
|
Map<String, dynamic> apiParams,
|
|
) {
|
|
_setLock(id);
|
|
_updateLocal(id, localPatch);
|
|
|
|
final timerKey = '$id:$key';
|
|
_debounceTimers[timerKey]?.cancel();
|
|
_debounceTimers[timerKey] = Timer(
|
|
const Duration(milliseconds: 300),
|
|
() async {
|
|
try {
|
|
await _api.controlGroup(id, apiParams);
|
|
} catch (e) {
|
|
_lockUntil.remove(id);
|
|
await refresh();
|
|
ref.read(groupControlErrorProvider.notifier).report(id, action, e);
|
|
}
|
|
},
|
|
);
|
|
}
|
|
|
|
Future<void> toggleGroup(String id, bool on) async {
|
|
_setLock(id);
|
|
_updateLocal(id, {'state': on});
|
|
try {
|
|
await _api.controlGroup(id, {'state': on});
|
|
} catch (e) {
|
|
_lockUntil.remove(id);
|
|
await refresh();
|
|
rethrow;
|
|
}
|
|
}
|
|
|
|
void setBrightness(String id, int value) {
|
|
_debouncedControl(
|
|
id,
|
|
'brightness',
|
|
'яркость',
|
|
{'brightness': value},
|
|
{'brightness': value},
|
|
);
|
|
}
|
|
|
|
void setTemperature(String id, int value) {
|
|
_debouncedControl(
|
|
id,
|
|
'temp',
|
|
'температуру',
|
|
{'temp': value},
|
|
{'temp': value},
|
|
);
|
|
}
|
|
|
|
void setColor(String id, int r, int g, int b) {
|
|
_debouncedControl(
|
|
id,
|
|
'color',
|
|
'цвет',
|
|
{'r': r, 'g': g, 'b': b},
|
|
{'r': r, 'g': g, 'b': b},
|
|
);
|
|
}
|
|
|
|
Future<void> setScene(String id, String scene) async {
|
|
_setLock(id);
|
|
_updateLocal(id, {'scene': scene});
|
|
try {
|
|
await _api.controlGroup(id, {'scene': scene});
|
|
} catch (e) {
|
|
_lockUntil.remove(id);
|
|
await refresh();
|
|
rethrow;
|
|
}
|
|
}
|
|
|
|
Future<void> setTimer4h(String id) async {
|
|
await toggleGroup(id, true);
|
|
await _api.scheduleOnce({
|
|
'target_id': id,
|
|
'state': false,
|
|
'hours_from_now': 4,
|
|
'is_group': true,
|
|
});
|
|
}
|
|
}
|
|
|
|
class GroupControlError {
|
|
final String groupId;
|
|
final String action;
|
|
final String message;
|
|
final int sequence;
|
|
|
|
const GroupControlError({
|
|
required this.groupId,
|
|
required this.action,
|
|
required this.message,
|
|
required this.sequence,
|
|
});
|
|
}
|
|
|
|
final groupControlErrorProvider =
|
|
NotifierProvider<GroupControlErrorNotifier, GroupControlError?>(
|
|
() => GroupControlErrorNotifier(),
|
|
);
|
|
|
|
class GroupControlErrorNotifier extends Notifier<GroupControlError?> {
|
|
int _sequence = 0;
|
|
|
|
@override
|
|
GroupControlError? build() => null;
|
|
|
|
void report(String groupId, String action, Object error) {
|
|
state = GroupControlError(
|
|
groupId: groupId,
|
|
action: action,
|
|
message: describeLoadError(error),
|
|
sequence: ++_sequence,
|
|
);
|
|
}
|
|
}
|
|
|
|
final devicesProvider =
|
|
NotifierProvider<DevicesNotifier, LoadState<List<IgnisDevice>>>(
|
|
() => DevicesNotifier(),
|
|
);
|
|
|
|
class DevicesNotifier extends Notifier<LoadState<List<IgnisDevice>>> {
|
|
@override
|
|
LoadState<List<IgnisDevice>> build() => const LoadState.idle(<IgnisDevice>[]);
|
|
|
|
Future<void> load() async {
|
|
state = LoadState.loading(state.data);
|
|
try {
|
|
final api = ref.read(apiProvider);
|
|
final res = await api.getDevices();
|
|
final devices = IgnisDevice.listFromApi(res.data);
|
|
|
|
state = devices.isEmpty
|
|
? LoadState.empty(devices)
|
|
: LoadState.data(devices);
|
|
} catch (e) {
|
|
state = LoadState.error(state.data, describeLoadError(e));
|
|
}
|
|
}
|
|
}
|
|
|
|
final scenesProvider =
|
|
NotifierProvider<ScenesNotifier, LoadState<List<IgnisScene>>>(
|
|
() => ScenesNotifier(),
|
|
);
|
|
|
|
class ScenesNotifier extends Notifier<LoadState<List<IgnisScene>>> {
|
|
@override
|
|
LoadState<List<IgnisScene>> build() => const LoadState.idle(<IgnisScene>[]);
|
|
|
|
Future<void> load() async {
|
|
state = LoadState.loading(state.data);
|
|
try {
|
|
final api = ref.read(apiProvider);
|
|
final res = await api.getScenes();
|
|
final scenes = IgnisScene.listFromApi(res.data);
|
|
|
|
state = scenes.isEmpty ? LoadState.empty(scenes) : LoadState.data(scenes);
|
|
} catch (e) {
|
|
state = LoadState.error(state.data, describeLoadError(e));
|
|
}
|
|
}
|
|
}
|