add new flush sensor device to app

lib/features/devices/bloc/flush_sensor_bloc/flush_sensor_bloc.dart

@@ -0,0 +1,129 @@
+import 'dart:async';
+import 'dart:developer';
+import 'package:firebase_database/firebase_database.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:syncrow_app/features/devices/bloc/flush_sensor_bloc/flush_sensor_event.dart';
+import 'package:syncrow_app/features/devices/bloc/flush_sensor_bloc/flush_sensor_state.dart';
+import 'package:syncrow_app/features/devices/model/device_control_model.dart';
+import 'package:syncrow_app/features/devices/model/device_model.dart';
+import 'package:syncrow_app/features/devices/model/flush_sensor_model.dart';
+import 'package:syncrow_app/features/devices/model/status_model.dart';
+import 'package:syncrow_app/services/api/devices_api.dart';
+
+class FlushSensorBloc extends Bloc<FlushSensorEvent, FlushSensorState> {
+  final String deviceId;
+  late DeviceModel deviceModel;
+  late FlushSensorModel deviceStatus;
+
+  FlushSensorBloc({required this.deviceId}) : super(InitialState()) {
+    on<InitialEvent>(_fetchFlushSensorStatus);
+    on<ChangeIndicatorEvent>(_changeIndicator);
+    on<ChangeValueEvent>(_changeValue);
+    on<WallSensorUpdatedEvent>(_flushSensorUpdated);
+    on<GetDeviceReportsEvent>(_getDeviceReports);
+  }
+
+  void _fetchFlushSensorStatus(
+      InitialEvent event, Emitter<FlushSensorState> emit) async {
+    emit(LoadingInitialState());
+    try {
+      var response = await DevicesAPI.getDeviceStatus(deviceId);
+      List<StatusModel> statusModelList = [];
+      for (var status in response['status']) {
+        statusModelList.add(StatusModel.fromJson(status));
+      }
+      deviceStatus = FlushSensorModel.fromJson(statusModelList);
+      emit(UpdateState(flushSensorModel: deviceStatus));
+      _listenToChanges();
+    } catch (e) {
+      emit(FailedState(error: e.toString()));
+      return;
+    }
+  }
+
+  StreamSubscription<DatabaseEvent>? _streamSubscription;
+
+  void _listenToChanges() {
+    try {
+      _streamSubscription?.cancel();
+      DatabaseReference ref =
+          FirebaseDatabase.instance.ref('device-status/$deviceId');
+      Stream<DatabaseEvent> stream = ref.onValue;
+
+      _streamSubscription = stream.listen((DatabaseEvent event) async {
+        Map<dynamic, dynamic> usersMap =
+            event.snapshot.value as Map<dynamic, dynamic>;
+        List<StatusModel> statusList = [];
+        usersMap['status'].forEach((element) {
+          statusList
+              .add(StatusModel(code: element['code'], value: element['value']));
+        });
+        deviceStatus = FlushSensorModel.fromJson(statusList);
+        if (!isClosed) {
+          add(WallSensorUpdatedEvent());
+        }
+      });
+    } catch (_) {
+      log(
+        'Error listening to changes',
+        name: 'FlushMountedPresenceSensorBloc._listenToChanges',
+      );
+    }
+  }
+
+  @override
+  Future<void> close() async {
+    _streamSubscription?.cancel();
+    _streamSubscription = null;
+    return super.close();
+  }
+
+  _flushSensorUpdated(
+      WallSensorUpdatedEvent event, Emitter<FlushSensorState> emit) {
+    emit(UpdateState(flushSensorModel: deviceStatus));
+  }
+
+  void _changeIndicator(
+      ChangeIndicatorEvent event, Emitter<FlushSensorState> emit) async {
+    emit(LoadingNewSate(flushSensorModel: deviceStatus));
+    try {
+      final response = await DevicesAPI.controlDevice(
+          DeviceControlModel(
+              deviceId: deviceId, code: 'indicator', value: !event.value),
+          deviceId);
+
+    } catch (e) {
+      emit(FailedState(error: e.toString()));
+      return;
+    }
+    emit(UpdateState(flushSensorModel: deviceStatus));
+  }
+
+  void _changeValue(
+      ChangeValueEvent event, Emitter<FlushSensorState> emit) async {
+    emit(LoadingNewSate(flushSensorModel: deviceStatus));
+    try {
+      final response = await DevicesAPI.controlDevice(
+          DeviceControlModel(
+              deviceId: deviceId, code: event.code, value: event.value),
+          deviceId);
+    } catch (e) {
+      emit(FailedState(error: e.toString()));
+      return;
+    }
+    emit(UpdateState(flushSensorModel: deviceStatus));
+  }
+
+  void _getDeviceReports(
+      GetDeviceReportsEvent event, Emitter<FlushSensorState> emit) async {
+    emit(LoadingInitialState());
+    try {
+      await DevicesAPI.getDeviceReports(deviceId, event.code).then((value) {
+        emit(DeviceReportsState(deviceReport: value, code: event.code));
+      });
+    } catch (e) {
+      emit(FailedState(error: e.toString()));
+      return;
+    }
+  }
+}

lib/features/devices/bloc/flush_sensor_bloc/flush_sensor_event.dart

@@ -0,0 +1,43 @@
+import 'package:equatable/equatable.dart';
+
+abstract class FlushSensorEvent extends Equatable {
+  const FlushSensorEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+class LoadingEvent extends FlushSensorEvent {}
+
+class InitialEvent extends FlushSensorEvent {}
+
+class WallSensorUpdatedEvent extends FlushSensorEvent {}
+
+class ChangeIndicatorEvent extends FlushSensorEvent {
+  final bool value;
+  const ChangeIndicatorEvent({required this.value});
+
+  @override
+  List<Object> get props => [value];
+}
+
+class ChangeValueEvent extends FlushSensorEvent {
+  final dynamic value;
+  final String code;
+  const ChangeValueEvent({required this.value, required this.code});
+
+  @override
+  List<Object> get props => [value, code];
+}
+
+class GetDeviceReportsEvent extends FlushSensorEvent {
+  final String deviceUuid;
+  final String code;
+  const GetDeviceReportsEvent({
+    required this.deviceUuid,
+    required this.code,
+  });
+
+  @override
+  List<Object> get props => [deviceUuid, code];
+}

lib/features/devices/bloc/flush_sensor_bloc/flush_sensor_state.dart

@@ -0,0 +1,45 @@
+import 'package:equatable/equatable.dart';
+import 'package:syncrow_app/features/devices/model/device_report_model.dart';
+import 'package:syncrow_app/features/devices/model/flush_sensor_model.dart';
+
+class FlushSensorState extends Equatable {
+  const FlushSensorState();
+
+  @override
+  List<Object> get props => [];
+}
+
+class InitialState extends FlushSensorState {}
+
+class LoadingInitialState extends FlushSensorState {}
+
+class UpdateState extends FlushSensorState {
+  final FlushSensorModel flushSensorModel;
+  const UpdateState({required this.flushSensorModel});
+
+  @override
+  List<Object> get props => [flushSensorModel];
+}
+
+class LoadingNewSate extends FlushSensorState {
+  final FlushSensorModel flushSensorModel;
+  const LoadingNewSate({required this.flushSensorModel});
+
+  @override
+  List<Object> get props => [flushSensorModel];
+}
+
+class FailedState extends FlushSensorState {
+  final String error;
+
+  const FailedState({required this.error});
+
+  @override
+  List<Object> get props => [error];
+}
+
+class DeviceReportsState extends FlushSensorState {
+  final DeviceReport deviceReport;
+  final String code;
+  const DeviceReportsState({required this.deviceReport, required this.code});
+}