claude refactorings, flutter best practices, platform dependent changes, general cleanup

lib/state/app/infrastructure/loadable_state/bloc/loadable_state_bloc.dart

@@ -0,0 +1,61 @@
+import 'dart:async';
+
+import 'package:connectivity_plus/connectivity_plus.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:jiffy/jiffy.dart';
+
+import 'loadable_state_event.dart';
+import 'loadable_state_state.dart';
+
+class LoadableStateBloc extends Bloc<LoadableStateEvent, LoadableStateState> {
+  late StreamSubscription<List<ConnectivityResult>> _updateStream;
+  void Function()? reFetch;
+
+  LoadableStateBloc() : super(const LoadableStateState(connections: null)) {
+    on<ConnectivityChanged>((event, emit) {
+      emit(event.state);
+      if(connectivityStatusKnown() && isConnected()) {
+        if(reFetch == null) return;
+        reFetch!();
+      }
+    });
+
+    void emitConnectivity(List<ConnectivityResult> result) => add(ConnectivityChanged(LoadableStateState(connections: result)));
+
+    Connectivity().checkConnectivity().then(emitConnectivity);
+    _updateStream = Connectivity().onConnectivityChanged.listen(emitConnectivity);
+  }
+
+  bool connectivityStatusKnown() => state.connections != null;
+  bool isConnected() => !(state.connections?.contains(ConnectivityResult.none) ?? true);
+  bool allowRetry() => reFetch != null;
+
+  IconData connectionIcon() => connectivityStatusKnown()
+      ? isConnected()
+        ? Icons.nearby_error
+        : Icons.signal_wifi_connected_no_internet_4
+      : Icons.device_unknown;
+
+  Color connectionColor(BuildContext context) => connectivityStatusKnown() && !isConnected()
+      ? Colors.grey.shade600
+      : Theme.of(context).primaryColor;
+
+  Color connectionForegroundColor(BuildContext context) => connectivityStatusKnown() && !isConnected()
+      ? Colors.white
+      : ThemeData.estimateBrightnessForColor(Theme.of(context).primaryColor) == Brightness.dark
+          ? Colors.white
+          : Colors.black;
+
+  String connectionText({int? lastUpdated}) => connectivityStatusKnown()
+      ? isConnected()
+        ? 'Verbindung fehlgeschlagen'
+        : 'Offline${lastUpdated == null ? '' : ' - Stand von ${Jiffy.parseFromMillisecondsSinceEpoch(lastUpdated).fromNow()}'}'
+      : 'Unbekannte Fehlerursache';
+
+  @override
+  Future<void> close() {
+    _updateStream.cancel();
+    return super.close();
+  }
+}

lib/state/app/infrastructure/loadable_state/bloc/loadable_state_event.dart

@@ -0,0 +1,7 @@
+import 'loadable_state_state.dart';
+
+sealed class LoadableStateEvent {}
+final class ConnectivityChanged extends LoadableStateEvent {
+  final LoadableStateState state;
+  ConnectivityChanged(this.state);
+}

lib/state/app/infrastructure/loadable_state/bloc/loadable_state_state.dart

@@ -0,0 +1,11 @@
+import 'package:connectivity_plus/connectivity_plus.dart';
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part 'loadable_state_state.freezed.dart';
+
+@freezed
+abstract class LoadableStateState with _$LoadableStateState {
+  const factory LoadableStateState({
+    required List<ConnectivityResult>? connections,
+  }) = _LoadableStateState;
+}

lib/state/app/infrastructure/loadable_state/bloc/loadable_state_state.freezed.dart

@@ -0,0 +1,279 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+// coverage:ignore-file
+// ignore_for_file: type=lint
+// ignore_for_file: unused_element, deprecated_member_use, deprecated_member_use_from_same_package, use_function_type_syntax_for_parameters, unnecessary_const, avoid_init_to_null, invalid_override_different_default_values_named, prefer_expression_function_bodies, annotate_overrides, invalid_annotation_target, unnecessary_question_mark
+
+part of 'loadable_state_state.dart';
+
+// **************************************************************************
+// FreezedGenerator
+// **************************************************************************
+
+// dart format off
+T _$identity<T>(T value) => value;
+/// @nodoc
+mixin _$LoadableStateState {
+
+ List<ConnectivityResult>? get connections;
+/// Create a copy of LoadableStateState
+/// with the given fields replaced by the non-null parameter values.
+@JsonKey(includeFromJson: false, includeToJson: false)
+@pragma('vm:prefer-inline')
+$LoadableStateStateCopyWith<LoadableStateState> get copyWith => _$LoadableStateStateCopyWithImpl<LoadableStateState>(this as LoadableStateState, _$identity);
+
+
+
+@override
+bool operator ==(Object other) {
+  return identical(this, other) || (other.runtimeType == runtimeType&&other is LoadableStateState&&const DeepCollectionEquality().equals(other.connections, connections));
+}
+
+
+@override
+int get hashCode => Object.hash(runtimeType,const DeepCollectionEquality().hash(connections));
+
+@override
+String toString() {
+  return 'LoadableStateState(connections: $connections)';
+}
+
+
+}
+
+/// @nodoc
+abstract mixin class $LoadableStateStateCopyWith<$Res>  {
+  factory $LoadableStateStateCopyWith(LoadableStateState value, $Res Function(LoadableStateState) _then) = _$LoadableStateStateCopyWithImpl;
+@useResult
+$Res call({
+ List<ConnectivityResult>? connections
+});
+
+
+
+
+}
+/// @nodoc
+class _$LoadableStateStateCopyWithImpl<$Res>
+    implements $LoadableStateStateCopyWith<$Res> {
+  _$LoadableStateStateCopyWithImpl(this._self, this._then);
+
+  final LoadableStateState _self;
+  final $Res Function(LoadableStateState) _then;
+
+/// Create a copy of LoadableStateState
+/// with the given fields replaced by the non-null parameter values.
+@pragma('vm:prefer-inline') @override $Res call({Object? connections = freezed,}) {
+  return _then(_self.copyWith(
+connections: freezed == connections ? _self.connections : connections // ignore: cast_nullable_to_non_nullable
+as List<ConnectivityResult>?,
+  ));
+}
+
+}
+
+
+/// Adds pattern-matching-related methods to [LoadableStateState].
+extension LoadableStateStatePatterns on LoadableStateState {
+/// A variant of `map` that fallback to returning `orElse`.
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case final Subclass value:
+///     return ...;
+///   case _:
+///     return orElse();
+/// }
+/// ```
+
+@optionalTypeArgs TResult maybeMap<TResult extends Object?>(TResult Function( _LoadableStateState value)?  $default,{required TResult orElse(),}){
+final _that = this;
+switch (_that) {
+case _LoadableStateState() when $default != null:
+return $default(_that);case _:
+  return orElse();
+
+}
+}
+/// A `switch`-like method, using callbacks.
+///
+/// Callbacks receives the raw object, upcasted.
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case final Subclass value:
+///     return ...;
+///   case final Subclass2 value:
+///     return ...;
+/// }
+/// ```
+
+@optionalTypeArgs TResult map<TResult extends Object?>(TResult Function( _LoadableStateState value)  $default,){
+final _that = this;
+switch (_that) {
+case _LoadableStateState():
+return $default(_that);case _:
+  throw StateError('Unexpected subclass');
+
+}
+}
+/// A variant of `map` that fallback to returning `null`.
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case final Subclass value:
+///     return ...;
+///   case _:
+///     return null;
+/// }
+/// ```
+
+@optionalTypeArgs TResult? mapOrNull<TResult extends Object?>(TResult? Function( _LoadableStateState value)?  $default,){
+final _that = this;
+switch (_that) {
+case _LoadableStateState() when $default != null:
+return $default(_that);case _:
+  return null;
+
+}
+}
+/// A variant of `when` that fallback to an `orElse` callback.
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case Subclass(:final field):
+///     return ...;
+///   case _:
+///     return orElse();
+/// }
+/// ```
+
+@optionalTypeArgs TResult maybeWhen<TResult extends Object?>(TResult Function( List<ConnectivityResult>? connections)?  $default,{required TResult orElse(),}) {final _that = this;
+switch (_that) {
+case _LoadableStateState() when $default != null:
+return $default(_that.connections);case _:
+  return orElse();
+
+}
+}
+/// A `switch`-like method, using callbacks.
+///
+/// As opposed to `map`, this offers destructuring.
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case Subclass(:final field):
+///     return ...;
+///   case Subclass2(:final field2):
+///     return ...;
+/// }
+/// ```
+
+@optionalTypeArgs TResult when<TResult extends Object?>(TResult Function( List<ConnectivityResult>? connections)  $default,) {final _that = this;
+switch (_that) {
+case _LoadableStateState():
+return $default(_that.connections);case _:
+  throw StateError('Unexpected subclass');
+
+}
+}
+/// A variant of `when` that fallback to returning `null`
+///
+/// It is equivalent to doing:
+/// ```dart
+/// switch (sealedClass) {
+///   case Subclass(:final field):
+///     return ...;
+///   case _:
+///     return null;
+/// }
+/// ```
+
+@optionalTypeArgs TResult? whenOrNull<TResult extends Object?>(TResult? Function( List<ConnectivityResult>? connections)?  $default,) {final _that = this;
+switch (_that) {
+case _LoadableStateState() when $default != null:
+return $default(_that.connections);case _:
+  return null;
+
+}
+}
+
+}
+
+/// @nodoc
+
+
+class _LoadableStateState implements LoadableStateState {
+  const _LoadableStateState({required final  List<ConnectivityResult>? connections}): _connections = connections;
+  
+
+ final  List<ConnectivityResult>? _connections;
+@override List<ConnectivityResult>? get connections {
+  final value = _connections;
+  if (value == null) return null;
+  if (_connections is EqualUnmodifiableListView) return _connections;
+  // ignore: implicit_dynamic_type
+  return EqualUnmodifiableListView(value);
+}
+
+
+/// Create a copy of LoadableStateState
+/// with the given fields replaced by the non-null parameter values.
+@override @JsonKey(includeFromJson: false, includeToJson: false)
+@pragma('vm:prefer-inline')
+_$LoadableStateStateCopyWith<_LoadableStateState> get copyWith => __$LoadableStateStateCopyWithImpl<_LoadableStateState>(this, _$identity);
+
+
+
+@override
+bool operator ==(Object other) {
+  return identical(this, other) || (other.runtimeType == runtimeType&&other is _LoadableStateState&&const DeepCollectionEquality().equals(other._connections, _connections));
+}
+
+
+@override
+int get hashCode => Object.hash(runtimeType,const DeepCollectionEquality().hash(_connections));
+
+@override
+String toString() {
+  return 'LoadableStateState(connections: $connections)';
+}
+
+
+}
+
+/// @nodoc
+abstract mixin class _$LoadableStateStateCopyWith<$Res> implements $LoadableStateStateCopyWith<$Res> {
+  factory _$LoadableStateStateCopyWith(_LoadableStateState value, $Res Function(_LoadableStateState) _then) = __$LoadableStateStateCopyWithImpl;
+@override @useResult
+$Res call({
+ List<ConnectivityResult>? connections
+});
+
+
+
+
+}
+/// @nodoc
+class __$LoadableStateStateCopyWithImpl<$Res>
+    implements _$LoadableStateStateCopyWith<$Res> {
+  __$LoadableStateStateCopyWithImpl(this._self, this._then);
+
+  final _LoadableStateState _self;
+  final $Res Function(_LoadableStateState) _then;
+
+/// Create a copy of LoadableStateState
+/// with the given fields replaced by the non-null parameter values.
+@override @pragma('vm:prefer-inline') $Res call({Object? connections = freezed,}) {
+  return _then(_LoadableStateState(
+connections: freezed == connections ? _self._connections : connections // ignore: cast_nullable_to_non_nullable
+as List<ConnectivityResult>?,
+  ));
+}
+
+
+}
+
+// dart format on