remove unused code

connect the real time for all devices
2026-03-11 06:51:46 +00:00 · 2025-03-03 17:34:15 +03:00 · 2025-03-01 15:19:15 +03:00 · 2025-03-01 15:08:51 +03:00 · 2025-02-26 12:20:06 +03:00 · 2025-02-26 12:17:57 +03:00
24 changed files with 1824 additions and 787 deletions
--- a/lib/features/devices/bloc/acs_bloc/acs_bloc.dart
+++ b/lib/features/devices/bloc/acs_bloc/acs_bloc.dart
@ -71,7 +71,7 @@ class ACsBloc extends Bloc<AcsEvent, AcsState> {
        deviceStatus = AcStatusModel.fromJson(response['productUuid'], statusModelList);
        emit(GetAcStatusState(acStatusModel: deviceStatus));
        Future.delayed(const Duration(milliseconds: 500));
-        // _listenToChanges();
+        _listenToChanges(acId);
      }
    } catch (e) {
      emit(AcsFailedState(errorMessage: e.toString()));
@ -79,25 +79,38 @@ class ACsBloc extends Bloc<AcsEvent, AcsState> {
    }
  }

-  _listenToChanges() {
+  StreamSubscription<DatabaseEvent>? _streamSubscription;
+
+  void _listenToChanges(acId) {
    try {
-      DatabaseReference ref = FirebaseDatabase.instance.ref('device-status/$acId');
+      _streamSubscription?.cancel();
+      DatabaseReference ref =
+          FirebaseDatabase.instance.ref('device-status/$acId');
      Stream<DatabaseEvent> stream = ref.onValue;

-      stream.listen((DatabaseEvent event) {
-        Map<dynamic, dynamic> usersMap = event.snapshot.value as Map<dynamic, dynamic>;
+      _streamSubscription = stream.listen((DatabaseEvent event) {
+        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 =
+            AcStatusModel.fromJson(usersMap['productUuid'], statusList);

-        deviceStatus = AcStatusModel.fromJson(usersMap['productUuid'], statusList);
        add(AcUpdated());
      });
    } catch (_) {}
  }

+  @override
+  Future<void> close() async {
+    _streamSubscription?.cancel();
+    _streamSubscription = null;
+    return super.close();
+  }
+
  _onAcUpdated(AcUpdated event, Emitter<AcsState> emit) {
    emit(GetAcStatusState(acStatusModel: deviceStatus));
  }
@ -109,13 +122,16 @@ class ACsBloc extends Bloc<AcsEvent, AcsState> {
        HomeCubit.getInstance().selectedSpace?.id ?? '', 'AC');

    for (int i = 0; i < devicesList.length; i++) {
-      var response = await DevicesAPI.getDeviceStatus(devicesList[i].uuid ?? '');
+      _listenToChanges(devicesList[i].uuid);
+      var response =
+          await DevicesAPI.getDeviceStatus(devicesList[i].uuid ?? '');
      List<StatusModel> statusModelList = [];
      for (var status in response['status']) {
        statusModelList.add(StatusModel.fromJson(status));
      }
      deviceStatusList.add(AcStatusModel.fromJson(devicesList[i].uuid ?? '', statusModelList));
    }
+
    _setAllAcsTempsAndSwitches();
  }

--- a/lib/features/devices/bloc/ceiling_bloc/ceiling_sensor_bloc.dart
+++ b/lib/features/devices/bloc/ceiling_bloc/ceiling_sensor_bloc.dart
@ -1,4 +1,4 @@
-import 'dart:convert';
+import 'dart:async';

 import 'package:dio/dio.dart';
 import 'package:firebase_database/firebase_database.dart';
@ -35,35 +35,49 @@ class CeilingSensorBloc extends Bloc<CeilingSensorEvent, CeilingSensorState> {
      }
      deviceStatus = CeilingSensorModel.fromJson(statusModelList);
      emit(UpdateState(ceilingSensorModel: deviceStatus));
-      // _listenToChanges();
+      _listenToChanges();
    } catch (e) {
      emit(FailedState(error: e.toString()));
      return;
    }
  }

-  _listenToChanges() {
+  StreamSubscription<DatabaseEvent>? _streamSubscription;
+  Timer? _timer;
+
+  void _listenToChanges() {
    try {
+      _streamSubscription?.cancel();
      DatabaseReference ref =
          FirebaseDatabase.instance.ref('device-status/$deviceId');
      Stream<DatabaseEvent> stream = ref.onValue;

-      stream.listen((DatabaseEvent event) {
+      _streamSubscription = stream.listen((DatabaseEvent event) async {
+        if (_timer != null) {
+          await Future.delayed(const Duration(seconds: 2));
+        }
        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 = CeilingSensorModel.fromJson(statusList);
-        add(CeilingSensorUpdated());
+        if (!isClosed) {
+          add(CeilingSensorUpdated());
+        }
      });
    } catch (_) {}
  }

+  @override
+  Future<void> close() async {
+    _streamSubscription?.cancel();
+    _streamSubscription = null;
+    return super.close();
+  }
+
  _onCeilingSensorUpdated(
      CeilingSensorUpdated event, Emitter<CeilingSensorState> emit) {
    emit(UpdateState(ceilingSensorModel: deviceStatus));
--- a/lib/features/devices/bloc/curtain_bloc/curtain_bloc.dart
+++ b/lib/features/devices/bloc/curtain_bloc/curtain_bloc.dart
@ -1,3 +1,5 @@
+import 'dart:async';
+import 'package:firebase_database/firebase_database.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:syncrow_app/features/app_layout/bloc/home_cubit.dart';
 import 'package:syncrow_app/features/devices/bloc/curtain_bloc/curtain_event.dart';
@ -30,6 +32,7 @@ class CurtainBloc extends Bloc<CurtainEvent, CurtainState> {
    on<InitialWizardEvent>(_fetchWizardStatus);
    on<GroupAllOffEvent>(_groupAllOff);
    on<GroupAllOnEvent>(_groupAllOn);
+    on<UpdateCurtainEvent>(_updateCurtain);
  }

  Future<void> _onOpenCurtain(
@ -161,7 +164,10 @@ class CurtainBloc extends Bloc<CurtainEvent, CurtainState> {
  void _fetchStatus(InitCurtain event, Emitter<CurtainState> emit) async {
    try {
      emit(CurtainLoadingState());
+      _listenToChanges(curtainId);
+
      var response = await DevicesAPI.getDeviceStatus(curtainId);
+
      List<StatusModel> statusModelList = [];
      for (var status in response['status']) {
        statusModelList.add(StatusModel.fromJson(status));
@ -169,7 +175,6 @@ class CurtainBloc extends Bloc<CurtainEvent, CurtainState> {
      openPercentage = double.tryParse(statusModelList[1].value.toString())!;
      curtainWidth = 270 - (openPercentage / 100) * curtainOpeningSpace;
      blindHeight = 310 - (openPercentage / 100) * blindOpeningSpace;
-
      emit(CurtainsOpening(
        curtainWidth: curtainWidth,
        blindHeight: blindHeight,
@ -181,6 +186,76 @@ class CurtainBloc extends Bloc<CurtainEvent, CurtainState> {
    }
  }

+  StreamSubscription<DatabaseEvent>? _streamSubscription;
+
+  void _listenToChanges(curtainId) {
+    try {
+      _streamSubscription?.cancel();
+      DatabaseReference ref =
+          FirebaseDatabase.instance.ref('device-status/$curtainId');
+      Stream<DatabaseEvent> stream = ref.onValue;
+
+      _streamSubscription = stream.listen((DatabaseEvent event) {
+        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']));
+        });
+        openPercentage = double.tryParse(statusList[1].value.toString())!;
+        curtainWidth = 270 - (openPercentage / 100) * curtainOpeningSpace;
+        blindHeight = 310 - (openPercentage / 100) * blindOpeningSpace;
+        add(UpdateCurtainEvent());
+      });
+    } catch (_) {}
+  }
+
+  @override
+  Future<void> close() async {
+    _streamSubscription?.cancel();
+    _streamSubscription = null;
+    return super.close();
+  }
+
+  // _listenToChanges(curtainId) {
+  //   try {
+  //     print('curtainId=$curtainId');
+  //     DatabaseReference ref =
+  //         FirebaseDatabase.instance.ref('device-status/$curtainId');
+  //     Stream<DatabaseEvent> stream = ref.onValue;
+
+  //     stream.listen((DatabaseEvent event) async {
+  //       if (_timer != null) {
+  //         await Future.delayed(const Duration(seconds: 2));
+  //       }
+  //       Map<dynamic, dynamic> usersMap =
+  //           event.snapshot.value as Map<dynamic, dynamic>;
+  //       List<StatusModel> statusModelList = [];
+  //       for (var status in usersMap['status']) {
+  //         statusModelList.add(StatusModel.fromJson(status));
+  //         print('statusModelList==${statusModelList}');
+  //       }
+
+  //       openPercentage = double.tryParse(statusModelList[1].value.toString())!;
+  //       curtainWidth = 270 - (openPercentage / 100) * curtainOpeningSpace;
+  //       blindHeight = 310 - (openPercentage / 100) * blindOpeningSpace;
+  //       add(UpdateCurtainEvent());
+  //     });
+  //   } catch (_) {}
+  // }
+
+  _updateCurtain(UpdateCurtainEvent event, Emitter<CurtainState> emit) {
+    curtainWidth = 270 - (openPercentage / 100) * curtainOpeningSpace;
+    blindHeight = 310 - (openPercentage / 100) * blindOpeningSpace;
+    emit(CurtainsOpening(
+      curtainWidth: curtainWidth,
+      blindHeight: blindHeight,
+      openPercentage: openPercentage,
+    ));
+  }
+
  List<GroupCurtainModel> groupList = [];
  bool allSwitchesOn = true;
  List<DeviceModel> devicesList = [];
--- a/lib/features/devices/bloc/curtain_bloc/curtain_event.dart
+++ b/lib/features/devices/bloc/curtain_bloc/curtain_event.dart
@ -33,6 +33,7 @@ class InitCurtain extends CurtainEvent {}
 class PauseCurtain extends CurtainEvent {}
 class useCurtainEvent extends CurtainEvent {}
 class InitialWizardEvent extends CurtainEvent {}
+class UpdateCurtainEvent extends CurtainEvent {}


 class ChangeFirstWizardSwitchStatusEvent extends CurtainEvent {
--- a/lib/features/devices/bloc/devices_cubit.dart
+++ b/lib/features/devices/bloc/devices_cubit.dart
@ -1,6 +1,9 @@
 // ignore_for_file: constant_identifier_names, unused_import

+import 'dart:async';
+
 import 'package:dio/dio.dart';
+import 'package:firebase_database/firebase_database.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:syncrow_app/features/app_layout/bloc/home_cubit.dart';
@ -63,6 +66,43 @@ class DevicesCubit extends Cubit<DevicesState> {
    }
  }

+  Timer? _timer;
+
+  final Map<String, StreamSubscription<DatabaseEvent>> _deviceSubscriptions =
+      {};
+
+  void _listenToChanges(deviceId) {
+    try {
+      if (_deviceSubscriptions.containsKey(deviceId)) {
+        _deviceSubscriptions[deviceId]?.cancel();
+        _deviceSubscriptions.remove(deviceId);
+      }
+      DatabaseReference ref =
+          FirebaseDatabase.instance.ref('device-status/$deviceId');
+      Stream<DatabaseEvent> stream = ref.onValue;
+      final subscription = stream.listen((DatabaseEvent event) async {
+        if (_timer != null) {
+          await Future.delayed(const Duration(seconds: 2));
+        }
+        Map<dynamic, dynamic> usersMap =
+            event.snapshot.value as Map<dynamic, dynamic>;
+        // print('object-----${usersMap['status']}');
+        List<StatusModel> statusList = [];
+        usersMap['status'].forEach((element) {
+          statusList
+              .add(StatusModel(code: element['code'], value: element['value']));
+        });
+        emitSafe(GetDevicesLoading());
+        final deviceIndex = allDevices.indexWhere((d) => d.uuid == deviceId);
+        if (deviceIndex != -1) {
+          allDevices[deviceIndex].status = statusList;
+        }
+        emitSafe(GetDevicesSuccess(allDevices));
+      });
+      _deviceSubscriptions[deviceId] = subscription;
+    } catch (_) {}
+  }
+
  static DevicesCubit get(context) => BlocProvider.of(context);

  List<DevicesCategoryModel>? allCategories;
@ -422,6 +462,19 @@ class DevicesCubit extends Cubit<DevicesState> {
          spaceUuid: unit.id,
          projectId: project?.uuid ?? TempConst.projectIdDev);
      allDevices = devices;
+      for (var deviceId in allDevices) {
+        if (deviceId.type == "3G" ||
+            deviceId.type == "2G" ||
+            deviceId.type == "1G" ||
+            deviceId.type == "3GT" ||
+            deviceId.type == "2GT" ||
+            deviceId.type == "1GT" ||
+            deviceId.type == "WH" ||
+            deviceId.type == "CUR" ||
+            deviceId.type == "AC") {
+          _listenToChanges(deviceId.uuid);
+        }
+      }
      emitSafe(GetDevicesSuccess(allDevices));
    } catch (e) {
      emitSafe(GetDevicesError(e.toString()));
@ -480,25 +533,35 @@ class DevicesCubit extends Cubit<DevicesState> {
      }
      final device = allDevices[deviceIndex];
      final switches = ['switch_1', 'switch_2', 'switch_3'];
+      final anySwitchOff = device.status.any(
+        (s) => (s.code?.startsWith('switch_') ?? false) && (s.value == false),
+      );
+      final targetState = anySwitchOff ? true : false;
+
      for (final switchCode in switches) {
        final statusIndex =
            device.status.indexWhere((s) => s.code == switchCode);
        if (statusIndex != -1) {
-          final toggledValue = control.value;
+          final currentValue = device.status[statusIndex].value ?? false;
+
+          if (!targetState && !currentValue) {
+            continue;
+          }
          final controlRequest = DeviceControlModel(
-              code: switchCode, value: toggledValue, deviceId: deviceUuid);
+              code: switchCode, value: targetState, deviceId: deviceUuid);
          final response =
              await DevicesAPI.controlDevice(controlRequest, deviceUuid);
          if (response['success'] != true) {
            throw Exception('Failed to toggle $switchCode');
          }
-          device.status[statusIndex].value = toggledValue;
+
+          device.status[statusIndex].value = targetState;
        }
      }
-      final anySwitchOff = device.status.any(
-        (s) => (s.code?.startsWith('switch_') ?? false) && (s.value == false),
+      device.toggleStatus = device.status.every(
+        (s) => (s.code?.startsWith('switch_') ?? false) && (s.value == true),
      );
-      device.toggleStatus = !anySwitchOff;
+
      allDevices[deviceIndex] = device;
      emit(DeviceControlSuccess(code: control.code));
    } catch (failure) {
@ -597,7 +660,6 @@ class DevicesCubit extends Cubit<DevicesState> {
            code: 'switch_1', value: toggledValue, deviceId: deviceUuid);
        final response =
            await DevicesAPI.controlDevice(controlRequest, deviceUuid);
-        print(response);
        if (response['result'] != true) {
          throw Exception('Failed to toggle switch_1');
        }
--- a/lib/features/devices/bloc/door_sensor_bloc/door_sensor_bloc.dart
+++ b/lib/features/devices/bloc/door_sensor_bloc/door_sensor_bloc.dart
@ -21,13 +21,14 @@ class DoorSensorBloc extends Bloc<DoorSensorEvent, DoorSensorState> {
    on<ToggleClosingReminderEvent>(_toggleClosingReminder);
    on<ToggleDoorAlarmEvent>(_toggleDoorAlarm);
  }
-  Timer? _timer;
  bool lowBattery = false;
  bool closingReminder = false;
  bool doorAlarm = false;
-  DoorSensorModel deviceStatus = DoorSensorModel(doorContactState: false, batteryPercentage: 0);
+  DoorSensorModel deviceStatus =
+      DoorSensorModel(doorContactState: false, batteryPercentage: 0);

-  void _fetchStatus(DoorSensorInitial event, Emitter<DoorSensorState> emit) async {
+  void _fetchStatus(
+      DoorSensorInitial event, Emitter<DoorSensorState> emit) async {
    emit(DoorSensorLoadingState());
    try {
      var response = await DevicesAPI.getDeviceStatus(DSId);
@ -40,7 +41,7 @@ class DoorSensorBloc extends Bloc<DoorSensorEvent, DoorSensorState> {
      );
      emit(UpdateState(doorSensor: deviceStatus));
      Future.delayed(const Duration(milliseconds: 500));
-      // _listenToChanges();
+      _listenToChanges();
    } catch (e) {
      emit(DoorSensorFailedState(errorMessage: e.toString()));
      return;
@ -48,7 +49,8 @@ class DoorSensorBloc extends Bloc<DoorSensorEvent, DoorSensorState> {
  }

  // Toggle functions for each switch
-  void _toggleLowBattery(ToggleLowBatteryEvent event, Emitter<DoorSensorState> emit) async {
+  void _toggleLowBattery(
+      ToggleLowBatteryEvent event, Emitter<DoorSensorState> emit) async {
    emit(LoadingNewSate(doorSensor: deviceStatus));
    try {
      lowBattery = event.isLowBatteryEnabled;
@ -89,7 +91,8 @@ class DoorSensorBloc extends Bloc<DoorSensorEvent, DoorSensorState> {
    }
  }

-  void _toggleDoorAlarm(ToggleDoorAlarmEvent event, Emitter<DoorSensorState> emit) async {
+  void _toggleDoorAlarm(
+      ToggleDoorAlarmEvent event, Emitter<DoorSensorState> emit) async {
    emit(LoadingNewSate(doorSensor: deviceStatus));
    try {
      doorAlarm = event.isDoorAlarmEnabled;
@ -108,9 +111,11 @@ class DoorSensorBloc extends Bloc<DoorSensorEvent, DoorSensorState> {
    }
  }

-  DeviceReport recordGroups = DeviceReport(startTime: '0', endTime: '0', data: []);
+  DeviceReport recordGroups =
+      DeviceReport(startTime: '0', endTime: '0', data: []);

-  Future<void> fetchLogsForLastMonth(ReportLogsInitial event, Emitter<DoorSensorState> emit) async {
+  Future<void> fetchLogsForLastMonth(
+      ReportLogsInitial event, Emitter<DoorSensorState> emit) async {
    DateTime now = DateTime.now();

    DateTime lastMonth = DateTime(now.year, now.month - 1, now.day);
@ -133,22 +138,27 @@ class DoorSensorBloc extends Bloc<DoorSensorEvent, DoorSensorState> {
    }
  }

-  _listenToChanges() {
+  // real-time database
+  Timer? _timer;
+  StreamSubscription<DatabaseEvent>? _streamSubscription;
+  void _listenToChanges() {
    try {
-      DatabaseReference ref = FirebaseDatabase.instance.ref('device-status/$DSId');
+      _streamSubscription?.cancel();
+      DatabaseReference ref =
+          FirebaseDatabase.instance.ref('device-status/$DSId');
      Stream<DatabaseEvent> stream = ref.onValue;

-      stream.listen((DatabaseEvent event) async {
+      _streamSubscription = stream.listen((DatabaseEvent event) async {
        if (_timer != null) {
          await Future.delayed(const Duration(seconds: 2));
        }
-        Map<dynamic, dynamic> usersMap = event.snapshot.value as Map<dynamic, dynamic>;
+        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: true));
+          statusList
+              .add(StatusModel(code: element['code'], value: element['value']));
        });
-
        deviceStatus = DoorSensorModel.fromJson(statusList);
        if (!isClosed) {
          add(
@ -158,4 +168,11 @@ class DoorSensorBloc extends Bloc<DoorSensorEvent, DoorSensorState> {
      });
    } catch (_) {}
  }
+
+  @override
+  Future<void> close() async {
+    _streamSubscription?.cancel();
+    _streamSubscription = null;
+    return super.close();
+  }
 }
--- a/lib/features/devices/bloc/four_scene_bloc/four_scene_bloc.dart
+++ b/lib/features/devices/bloc/four_scene_bloc/four_scene_bloc.dart
@ -233,6 +233,7 @@ class FourSceneBloc extends Bloc<FourSceneEvent, FourSceneState> {
      deviceStatus = FourSceneModelState.fromJson(
        statusModelList,
      );
+      // _listenToChanges();
      add(const FourSceneSwitchInitial());
    } catch (e) {
      emit(FourSceneFailedState(errorMessage: e.toString()));
@ -332,4 +333,33 @@ class FourSceneBloc extends Bloc<FourSceneEvent, FourSceneState> {
          }).toList();
    emit(SearchResultsState());
  }
+  // Real-time database
+  // Timer? _timer;
+  // _listenToChanges() {
+  //   try {
+  //     DatabaseReference ref =
+  //         FirebaseDatabase.instance.ref('device-status/$fourSceneId');
+  //     Stream<DatabaseEvent> stream = ref.onValue;
+
+  //     stream.listen((DatabaseEvent event) async {
+  //       if (_timer != null) {
+  //         await Future.delayed(const Duration(seconds: 2));
+  //       }
+  //       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: true));
+  //       });
+
+  //       deviceStatus = FourSceneModelState.fromJson(statusList);
+  //       // if (!isClosed) {
+  //       //   add(
+  //       //     DoorSensorSwitch(switchD: deviceStatus.doorContactState),
+  //       //   );
+  //       // }
+  //     });
+  //   } catch (_) {}
+  // }
 }
--- a/lib/features/devices/bloc/garage_door_bloc/garage_door_bloc.dart
+++ b/lib/features/devices/bloc/garage_door_bloc/garage_door_bloc.dart
@ -42,7 +42,8 @@ class GarageDoorBloc extends Bloc<GarageDoorEvent, GarageDoorSensorState> {
    on<ChangeFirstWizardSwitchStatusEvent>(_changeFirstWizardSwitch);
    on<ToggleAlarmEvent>(_toggleAlarmEvent);
    on<DeleteScheduleEvent>(deleteSchedule);
-    //_toggleAlarmEvent
+
+    on<UpdateStateEvent>(_updateState);
  }
  void _onClose(OnClose event, Emitter<GarageDoorSensorState> emit) {
    _timer?.cancel();
@ -81,7 +82,7 @@ class GarageDoorBloc extends Bloc<GarageDoorEvent, GarageDoorSensorState> {
      toggleDoor = deviceStatus.switch1;
      emit(UpdateState(garageSensor: deviceStatus));
      Future.delayed(const Duration(milliseconds: 500));
-      // _listenToChanges();
+      _listenToChanges();
    } catch (e) {
      emit(GarageDoorFailedState(errorMessage: e.toString()));
      return;
@ -180,33 +181,59 @@ class GarageDoorBloc extends Bloc<GarageDoorEvent, GarageDoorSensorState> {
    }
  }

-  _listenToChanges() {
+  // Real-time db
+  StreamSubscription<DatabaseEvent>? _streamSubscription;
+  void _listenToChanges() {
    try {
+      _streamSubscription?.cancel();
      DatabaseReference ref =
          FirebaseDatabase.instance.ref('device-status/$GDId');
      Stream<DatabaseEvent> stream = ref.onValue;

-      stream.listen((DatabaseEvent event) async {
+      _streamSubscription = stream.listen((DatabaseEvent event) async {
        if (_timer != null) {
-          await Future.delayed(const Duration(seconds: 2));
+          await Future.delayed(const Duration(seconds: 1));
        }
-        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: true));
-        });

-        deviceStatus = GarageDoorModel.fromJson(statusList);
-        if (!isClosed) {
-          // add(
-          //   DoorSensorSwitch(switchD: deviceStatus.doorContactState),
-          // );
+        if (event.snapshot.value != null) {
+          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.tr_timecon = statusList
+              .firstWhere((status) => status.code == "tr_timecon",
+                  orElse: () => StatusModel(code: "tr_timecon", value: 0))
+              .value as int;
+
+          deviceStatus.switch1 = statusList
+              .firstWhere((status) => status.code == "switch_1",
+                  orElse: () => StatusModel(code: "switch_1", value: false))
+              .value as bool;
+          secondSelected = deviceStatus.tr_timecon;
+          toggleDoor = deviceStatus.switch1;
+          add(UpdateStateEvent());
        }
      });
    } catch (_) {}
  }

+  Future<void> _updateState(
+      UpdateStateEvent event, Emitter<GarageDoorSensorState> emit) async {
+    emit(GarageDoorLoadingState());
+    emit(UpdateState(garageSensor: deviceStatus));
+  }
+
+  @override
+  Future<void> close() async {
+    _streamSubscription?.cancel();
+    _streamSubscription = null;
+    return super.close();
+  }
+
  List<Map<String, String>> days = [
    {"day": "Sun", "key": "Sun"},
    {"day": "Mon", "key": "Mon"},
--- a/lib/features/devices/bloc/garage_door_bloc/garage_door_event.dart
+++ b/lib/features/devices/bloc/garage_door_bloc/garage_door_event.dart
@ -109,6 +109,8 @@ class GetScheduleEvent extends GarageDoorEvent {}

 class ScheduleSaveapp extends GarageDoorEvent {}

+class UpdateStateEvent extends GarageDoorEvent {}
+
 class ToggleScheduleEvent extends GarageDoorEvent {
  final String id;
  final bool toggle;
--- a/lib/features/devices/bloc/one_gang_bloc/one_gang_bloc.dart
+++ b/lib/features/devices/bloc/one_gang_bloc/one_gang_bloc.dart
@ -26,7 +26,8 @@ class OneGangBloc extends Bloc<OneGangEvent, OneGangState> {
  bool oneGangGroup = false;
  List<DeviceModel> devicesList = [];

-  OneGangBloc({required this.oneGangId, required this.switchCode}) : super(InitialState()) {
+  OneGangBloc({required this.oneGangId, required this.switchCode})
+      : super(InitialState()) {
    on<InitialEvent>(_fetchOneGangStatus);
    on<OneGangUpdated>(_oneGangUpdated);
    on<ChangeFirstSwitchStatusEvent>(_changeFirstSwitch);
@ -49,7 +50,8 @@ class OneGangBloc extends Bloc<OneGangEvent, OneGangState> {
    on<GroupAllOffEvent>(_groupAllOff);
  }

-  void _fetchOneGangStatus(InitialEvent event, Emitter<OneGangState> emit) async {
+  void _fetchOneGangStatus(
+      InitialEvent event, Emitter<OneGangState> emit) async {
    emit(LoadingInitialState());
    try {
      var response = await DevicesAPI.getDeviceStatus(oneGangId);
@ -59,42 +61,51 @@ class OneGangBloc extends Bloc<OneGangEvent, OneGangState> {
      }
      deviceStatus = OneGangModel.fromJson(statusModelList);
      emit(UpdateState(oneGangModel: deviceStatus));
-      // _listenToChanges();
+      _listenToChanges(oneGangId);
    } catch (e) {
      emit(FailedState(error: e.toString()));
      return;
    }
  }

-  _listenToChanges() {
+  // Real-time db
+  StreamSubscription<DatabaseEvent>? _streamSubscription;
+  void _listenToChanges(String id) {
    try {
-      DatabaseReference ref = FirebaseDatabase.instance.ref('device-status/$oneGangId');
+      _streamSubscription?.cancel();
+      DatabaseReference ref =
+          FirebaseDatabase.instance.ref('device-status/$id'); 
      Stream<DatabaseEvent> stream = ref.onValue;

-      stream.listen((DatabaseEvent event) async {
-        if (_timer != null) {
-          await Future.delayed(const Duration(seconds: 2));
-        }
-        Map<dynamic, dynamic> usersMap = event.snapshot.value as Map<dynamic, dynamic>;
+      _streamSubscription = stream.listen((DatabaseEvent event) {
+        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']));
+          statusList
+              .add(StatusModel(code: element['code'], value: element['value']));
        });
-
        deviceStatus = OneGangModel.fromJson(statusList);
-        if (!isClosed) {
-          add(OneGangUpdated());
-        }
+        add(OneGangUpdated());
      });
    } catch (_) {}
  }

+  @override
+  Future<void> close() async {
+    _streamSubscription?.cancel();
+    _streamSubscription = null;
+    return super.close();
+  }
+
  _oneGangUpdated(OneGangUpdated event, Emitter<OneGangState> emit) {
+    emit(LoadingInitialState());
    emit(UpdateState(oneGangModel: deviceStatus));
  }

-  void _changeFirstSwitch(ChangeFirstSwitchStatusEvent event, Emitter<OneGangState> emit) async {
+  void _changeFirstSwitch(
+      ChangeFirstSwitchStatusEvent event, Emitter<OneGangState> emit) async {
    emit(LoadingNewSate(oneGangModel: deviceStatus));
    try {
      deviceStatus.firstSwitch = !event.value;
@ -119,17 +130,20 @@ class OneGangBloc extends Bloc<OneGangEvent, OneGangState> {
    }
  }

-  void _changeSliding(ChangeSlidingSegment event, Emitter<OneGangState> emit) async {
+  void _changeSliding(
+      ChangeSlidingSegment event, Emitter<OneGangState> emit) async {
    emit(ChangeSlidingSegmentState(value: event.value));
  }

-  void _setCounterValue(SetCounterValue event, Emitter<OneGangState> emit) async {
+  void _setCounterValue(
+      SetCounterValue event, Emitter<OneGangState> emit) async {
    emit(LoadingNewSate(oneGangModel: deviceStatus));
    int seconds = 0;
    try {
      seconds = event.duration.inSeconds;
      final response = await DevicesAPI.controlDevice(
-          DeviceControlModel(deviceId: oneGangId, code: event.deviceCode, value: seconds),
+          DeviceControlModel(
+              deviceId: oneGangId, code: event.deviceCode, value: seconds),
          oneGangId);

      if (response['success'] ?? false) {
@ -152,7 +166,8 @@ class OneGangBloc extends Bloc<OneGangEvent, OneGangState> {
    }
  }

-  void _getCounterValue(GetCounterEvent event, Emitter<OneGangState> emit) async {
+  void _getCounterValue(
+      GetCounterEvent event, Emitter<OneGangState> emit) async {
    emit(LoadingInitialState());
    try {
      var response = await DevicesAPI.getDeviceStatus(oneGangId);
@ -241,7 +256,8 @@ class OneGangBloc extends Bloc<OneGangEvent, OneGangState> {
        deviceId: oneGangId,
      );
      List<dynamic> jsonData = response;
-      listSchedule = jsonData.map((item) => ScheduleModel.fromJson(item)).toList();
+      listSchedule =
+          jsonData.map((item) => ScheduleModel.fromJson(item)).toList();
      emit(InitialState());
    } on DioException catch (e) {
      final errorData = e.response!.data;
@ -252,12 +268,13 @@ class OneGangBloc extends Bloc<OneGangEvent, OneGangState> {

  int? getTimeStampWithoutSeconds(DateTime? dateTime) {
    if (dateTime == null) return null;
-    DateTime dateTimeWithoutSeconds =
-        DateTime(dateTime.year, dateTime.month, dateTime.day, dateTime.hour, dateTime.minute);
+    DateTime dateTimeWithoutSeconds = DateTime(dateTime.year, dateTime.month,
+        dateTime.day, dateTime.hour, dateTime.minute);
    return dateTimeWithoutSeconds.millisecondsSinceEpoch ~/ 1000;
  }

-  Future toggleChange(ToggleScheduleEvent event, Emitter<OneGangState> emit) async {
+  Future toggleChange(
+      ToggleScheduleEvent event, Emitter<OneGangState> emit) async {
    try {
      emit(LoadingInitialState());
      final response = await DevicesAPI.changeSchedule(
@ -276,7 +293,8 @@ class OneGangBloc extends Bloc<OneGangEvent, OneGangState> {
    }
  }

-  Future deleteSchedule(DeleteScheduleEvent event, Emitter<OneGangState> emit) async {
+  Future deleteSchedule(
+      DeleteScheduleEvent event, Emitter<OneGangState> emit) async {
    try {
      emit(LoadingInitialState());
      final response = await DevicesAPI.deleteSchedule(
@ -296,7 +314,8 @@ class OneGangBloc extends Bloc<OneGangEvent, OneGangState> {
    }
  }

-  void toggleCreateSchedule(ToggleCreateScheduleEvent event, Emitter<OneGangState> emit) {
+  void toggleCreateSchedule(
+      ToggleCreateScheduleEvent event, Emitter<OneGangState> emit) {
    emit(LoadingInitialState());
    createSchedule = !createSchedule;
    selectedDays.clear();
@ -325,7 +344,8 @@ class OneGangBloc extends Bloc<OneGangEvent, OneGangState> {

  int selectedTabIndex = 0;

-  void toggleSelectedIndex(ToggleSelectedEvent event, Emitter<OneGangState> emit) {
+  void toggleSelectedIndex(
+      ToggleSelectedEvent event, Emitter<OneGangState> emit) {
    emit(LoadingInitialState());
    selectedTabIndex = event.index;
    emit(ChangeSlidingSegmentState(value: selectedTabIndex));
@ -334,7 +354,8 @@ class OneGangBloc extends Bloc<OneGangEvent, OneGangState> {
  List<GroupOneGangModel> groupOneGangList = [];
  bool allSwitchesOn = true;

-  void _fetchOneGangWizardStatus(InitialWizardEvent event, Emitter<OneGangState> emit) async {
+  void _fetchOneGangWizardStatus(
+      InitialWizardEvent event, Emitter<OneGangState> emit) async {
    emit(LoadingInitialState());
    try {
      devicesList = [];
@ -344,7 +365,8 @@ class OneGangBloc extends Bloc<OneGangEvent, OneGangState> {
          HomeCubit.getInstance().selectedSpace?.id ?? '', '1G');

      for (int i = 0; i < devicesList.length; i++) {
-        var response = await DevicesAPI.getDeviceStatus(devicesList[i].uuid ?? '');
+        var response =
+            await DevicesAPI.getDeviceStatus(devicesList[i].uuid ?? '');
        List<StatusModel> statusModelList = [];
        for (var status in response['status']) {
          statusModelList.add(StatusModel.fromJson(status));
@ -365,15 +387,16 @@ class OneGangBloc extends Bloc<OneGangEvent, OneGangState> {
          return true;
        });
      }
-      emit(UpdateGroupState(oneGangList: groupOneGangList, allSwitches: allSwitchesOn));
+      emit(UpdateGroupState(
+          oneGangList: groupOneGangList, allSwitches: allSwitchesOn));
    } catch (e) {
      emit(FailedState(error: e.toString()));
      return;
    }
  }

-  void _changeFirstWizardSwitch(
-      ChangeFirstWizardSwitchStatusEvent event, Emitter<OneGangState> emit) async {
+  void _changeFirstWizardSwitch(ChangeFirstWizardSwitchStatusEvent event,
+      Emitter<OneGangState> emit) async {
    emit(LoadingNewSate(oneGangModel: deviceStatus));
    try {
      bool allSwitchesValue = true;
@ -386,7 +409,8 @@ class OneGangBloc extends Bloc<OneGangEvent, OneGangState> {
        }
      });

-      emit(UpdateGroupState(oneGangList: groupOneGangList, allSwitches: allSwitchesValue));
+      emit(UpdateGroupState(
+          oneGangList: groupOneGangList, allSwitches: allSwitchesValue));

      final response = await DevicesAPI.deviceBatchController(
        code: 'switch_1',
@ -414,7 +438,8 @@ class OneGangBloc extends Bloc<OneGangEvent, OneGangState> {
      emit(UpdateGroupState(oneGangList: groupOneGangList, allSwitches: true));

      // Get a list of all device IDs
-      List<String> allDeviceIds = groupOneGangList.map((device) => device.deviceId).toList();
+      List<String> allDeviceIds =
+          groupOneGangList.map((device) => device.deviceId).toList();

      // First call for switch_1
      final response = await DevicesAPI.deviceBatchController(
@ -446,7 +471,8 @@ class OneGangBloc extends Bloc<OneGangEvent, OneGangState> {
      emit(UpdateGroupState(oneGangList: groupOneGangList, allSwitches: false));

      // Get a list of all device IDs
-      List<String> allDeviceIds = groupOneGangList.map((device) => device.deviceId).toList();
+      List<String> allDeviceIds =
+          groupOneGangList.map((device) => device.deviceId).toList();

      // First call for switch_1
      final response = await DevicesAPI.deviceBatchController(
--- a/lib/features/devices/bloc/one_touch_bloc/one_touch_bloc.dart
+++ b/lib/features/devices/bloc/one_touch_bloc/one_touch_bloc.dart
@ -30,7 +30,8 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {
  bool oneTouchGroup = false;
  List<DeviceModel> devicesList = [];

-  OneTouchBloc({required this.oneTouchId, required this.switchCode}) : super(InitialState()) {
+  OneTouchBloc({required this.oneTouchId, required this.switchCode})
+      : super(InitialState()) {
    on<InitialEvent>(_fetchOneTouchStatus);
    on<OneTouchUpdated>(_oneTouchUpdated);
    on<ChangeFirstSwitchStatusEvent>(_changeFirstSwitch);
@ -53,7 +54,8 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {
    on<ChangeStatusEvent>(_changeStatus);
  }

-  void _fetchOneTouchStatus(InitialEvent event, Emitter<OneTouchState> emit) async {
+  void _fetchOneTouchStatus(
+      InitialEvent event, Emitter<OneTouchState> emit) async {
    emit(LoadingInitialState());
    try {
      var response = await DevicesAPI.getDeviceStatus(oneTouchId);
@ -62,43 +64,59 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {
        statusModelList.add(StatusModel.fromJson(status));
      }
      deviceStatus = OneTouchModel.fromJson(statusModelList);
+      _listenToChanges(oneTouchId);
+
      emit(UpdateState(oneTouchModel: deviceStatus));
-      // _listenToChanges();
    } catch (e) {
      emit(FailedState(error: e.toString()));
      return;
    }
  }

-  _listenToChanges() {
+  StreamSubscription<DatabaseEvent>? _streamSubscription;
+  void _listenToChanges(String id) {
    try {
-      DatabaseReference ref = FirebaseDatabase.instance.ref('device-status/$oneTouchId');
+      _streamSubscription?.cancel();
+      DatabaseReference ref =
+          FirebaseDatabase.instance.ref('device-status/$id');
      Stream<DatabaseEvent> stream = ref.onValue;

-      stream.listen((DatabaseEvent event) async {
-        if (_timer != null) {
-          await Future.delayed(const Duration(seconds: 2));
-        }
-        Map<dynamic, dynamic> usersMap = event.snapshot.value as Map<dynamic, dynamic>;
-        List<StatusModel> statusList = [];
+      _streamSubscription = stream.listen((DatabaseEvent event) {
+        if (event.snapshot.value != null) {
+          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']));
-        });
+          usersMap['status'].forEach((element) {
+            statusList.add(
+                StatusModel(code: element['code'], value: element['value']));
+          });
+          var switchStatus = statusList.firstWhere(
+              (status) => status.code == "switch_1",
+              orElse: () => StatusModel(code: "switch_1", value: false));

-        deviceStatus = OneTouchModel.fromJson(statusList);
-        if (!isClosed) {
+          deviceStatus.firstSwitch = switchStatus.value as bool;
          add(OneTouchUpdated());
        }
      });
-    } catch (_) {}
+    } catch (_) {
+    }
+  }
+
+  @override
+  Future<void> close() async {
+    _streamSubscription?.cancel();
+    _streamSubscription = null;
+    return super.close();
  }

  _oneTouchUpdated(OneTouchUpdated event, Emitter<OneTouchState> emit) {
+    emit(LoadingNewSate(oneTouchModel: deviceStatus));
    emit(UpdateState(oneTouchModel: deviceStatus));
  }

-  void _changeFirstSwitch(ChangeFirstSwitchStatusEvent event, Emitter<OneTouchState> emit) async {
+  void _changeFirstSwitch(
+      ChangeFirstSwitchStatusEvent event, Emitter<OneTouchState> emit) async {
    emit(LoadingNewSate(oneTouchModel: deviceStatus));
    try {
      deviceStatus.firstSwitch = !event.value;
@ -123,17 +141,20 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {
    }
  }

-  void _changeSliding(ChangeSlidingSegment event, Emitter<OneTouchState> emit) async {
+  void _changeSliding(
+      ChangeSlidingSegment event, Emitter<OneTouchState> emit) async {
    emit(ChangeSlidingSegmentState(value: event.value));
  }

-  void _setCounterValue(SetCounterValue event, Emitter<OneTouchState> emit) async {
+  void _setCounterValue(
+      SetCounterValue event, Emitter<OneTouchState> emit) async {
    emit(LoadingNewSate(oneTouchModel: deviceStatus));
    int seconds = 0;
    try {
      seconds = event.duration.inSeconds;
      final response = await DevicesAPI.controlDevice(
-          DeviceControlModel(deviceId: oneTouchId, code: event.deviceCode, value: seconds),
+          DeviceControlModel(
+              deviceId: oneTouchId, code: event.deviceCode, value: seconds),
          oneTouchId);

      if (response['success'] ?? false) {
@ -156,7 +177,8 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {
    }
  }

-  void _getCounterValue(GetCounterEvent event, Emitter<OneTouchState> emit) async {
+  void _getCounterValue(
+      GetCounterEvent event, Emitter<OneTouchState> emit) async {
    emit(LoadingInitialState());
    try {
      var response = await DevicesAPI.getDeviceStatus(oneTouchId);
@ -245,7 +267,8 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {
        deviceId: oneTouchId,
      );
      List<dynamic> jsonData = response;
-      listSchedule = jsonData.map((item) => ScheduleModel.fromJson(item)).toList();
+      listSchedule =
+          jsonData.map((item) => ScheduleModel.fromJson(item)).toList();
      emit(InitialState());
    } on DioException catch (e) {
      final errorData = e.response!.data;
@ -256,12 +279,13 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {

  int? getTimeStampWithoutSeconds(DateTime? dateTime) {
    if (dateTime == null) return null;
-    DateTime dateTimeWithoutSeconds =
-        DateTime(dateTime.year, dateTime.month, dateTime.day, dateTime.hour, dateTime.minute);
+    DateTime dateTimeWithoutSeconds = DateTime(dateTime.year, dateTime.month,
+        dateTime.day, dateTime.hour, dateTime.minute);
    return dateTimeWithoutSeconds.millisecondsSinceEpoch ~/ 1000;
  }

-  Future toggleChange(ToggleScheduleEvent event, Emitter<OneTouchState> emit) async {
+  Future toggleChange(
+      ToggleScheduleEvent event, Emitter<OneTouchState> emit) async {
    try {
      emit(LoadingInitialState());
      final response = await DevicesAPI.changeSchedule(
@ -280,7 +304,8 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {
    }
  }

-  Future deleteSchedule(DeleteScheduleEvent event, Emitter<OneTouchState> emit) async {
+  Future deleteSchedule(
+      DeleteScheduleEvent event, Emitter<OneTouchState> emit) async {
    try {
      emit(LoadingInitialState());
      final response = await DevicesAPI.deleteSchedule(
@ -300,7 +325,8 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {
    }
  }

-  void toggleCreateSchedule(ToggleCreateScheduleEvent event, Emitter<OneTouchState> emit) {
+  void toggleCreateSchedule(
+      ToggleCreateScheduleEvent event, Emitter<OneTouchState> emit) {
    emit(LoadingInitialState());
    createSchedule = !createSchedule;
    selectedDays.clear();
@ -329,7 +355,8 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {

  int selectedTabIndex = 0;

-  void toggleSelectedIndex(ToggleSelectedEvent event, Emitter<OneTouchState> emit) {
+  void toggleSelectedIndex(
+      ToggleSelectedEvent event, Emitter<OneTouchState> emit) {
    emit(LoadingInitialState());
    selectedTabIndex = event.index;
    emit(ChangeSlidingSegmentState(value: selectedTabIndex));
@ -338,7 +365,8 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {
  List<GroupOneTouchModel> groupOneTouchList = [];
  bool allSwitchesOn = true;

-  void _fetchOneTouchWizardStatus(InitialWizardEvent event, Emitter<OneTouchState> emit) async {
+  void _fetchOneTouchWizardStatus(
+      InitialWizardEvent event, Emitter<OneTouchState> emit) async {
    emit(LoadingInitialState());
    try {
      devicesList = [];
@ -348,7 +376,8 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {
          HomeCubit.getInstance().selectedSpace?.id ?? '', '1GT');

      for (int i = 0; i < devicesList.length; i++) {
-        var response = await DevicesAPI.getDeviceStatus(devicesList[i].uuid ?? '');
+        var response =
+            await DevicesAPI.getDeviceStatus(devicesList[i].uuid ?? '');
        List<StatusModel> statusModelList = [];
        for (var status in response['status']) {
          statusModelList.add(StatusModel.fromJson(status));
@ -369,15 +398,16 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {
          return true;
        });
      }
-      emit(UpdateGroupState(oneTouchList: groupOneTouchList, allSwitches: allSwitchesOn));
+      emit(UpdateGroupState(
+          oneTouchList: groupOneTouchList, allSwitches: allSwitchesOn));
    } catch (e) {
      emit(FailedState(error: e.toString()));
      return;
    }
  }

-  void _changeFirstWizardSwitch(
-      ChangeFirstWizardSwitchStatusEvent event, Emitter<OneTouchState> emit) async {
+  void _changeFirstWizardSwitch(ChangeFirstWizardSwitchStatusEvent event,
+      Emitter<OneTouchState> emit) async {
    emit(LoadingNewSate(oneTouchModel: deviceStatus));
    try {
      bool allSwitchesValue = true;
@ -395,7 +425,8 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {
        value: !event.value,
      );

-      emit(UpdateGroupState(oneTouchList: groupOneTouchList, allSwitches: allSwitchesValue));
+      emit(UpdateGroupState(
+          oneTouchList: groupOneTouchList, allSwitches: allSwitchesValue));
      if (response['success']) {
        add(InitialEvent(groupScreen: oneTouchGroup));
      }
@ -413,10 +444,12 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {
      }

      // Emit the state with updated values
-      emit(UpdateGroupState(oneTouchList: groupOneTouchList, allSwitches: true));
+      emit(
+          UpdateGroupState(oneTouchList: groupOneTouchList, allSwitches: true));

      // Get a list of all device IDs
-      List<String> allDeviceIds = groupOneTouchList.map((device) => device.deviceId).toList();
+      List<String> allDeviceIds =
+          groupOneTouchList.map((device) => device.deviceId).toList();

      // First call for switch_1
      final response1 = await DevicesAPI.deviceBatchController(
@ -445,10 +478,12 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {
      }

      // Emit the state with updated values
-      emit(UpdateGroupState(oneTouchList: groupOneTouchList, allSwitches: false));
+      emit(UpdateGroupState(
+          oneTouchList: groupOneTouchList, allSwitches: false));

      // Get a list of all device IDs
-      List<String> allDeviceIds = groupOneTouchList.map((device) => device.deviceId).toList();
+      List<String> allDeviceIds =
+          groupOneTouchList.map((device) => device.deviceId).toList();

      // First call for switch_1
      final response1 = await DevicesAPI.deviceBatchController(
@ -472,7 +507,8 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {
  String statusSelected = '';
  String optionSelected = '';

-  Future<void> _changeStatus(ChangeStatusEvent event, Emitter<OneTouchState> emit) async {
+  Future<void> _changeStatus(
+      ChangeStatusEvent event, Emitter<OneTouchState> emit) async {
    try {
      emit(LoadingInitialState());

@ -497,7 +533,10 @@ class OneTouchBloc extends Bloc<OneTouchEvent, OneTouchState> {
      final selectedControl = controlMap[optionSelected]?[statusSelected];
      if (selectedControl != null) {
        await DevicesAPI.controlDevice(
-          DeviceControlModel(deviceId: oneTouchId, code: optionSelected, value: selectedControl),
+          DeviceControlModel(
+              deviceId: oneTouchId,
+              code: optionSelected,
+              value: selectedControl),
          oneTouchId,
        );
      } else {
--- a/lib/features/devices/bloc/smart_door_bloc/smart_door_bloc.dart
+++ b/lib/features/devices/bloc/smart_door_bloc/smart_door_bloc.dart
@ -1,3 +1,4 @@
+import 'dart:async';
 import 'dart:math';
 import 'package:firebase_database/firebase_database.dart';
 import 'package:flutter/material.dart';
@ -37,7 +38,8 @@ class SmartDoorBloc extends Bloc<SmartDoorEvent, SmartDoorState> {
    on<SelectTimeEvent>(selectTimeOfLinePassword);
    on<SelectTimeOnlinePasswordEvent>(selectTimeOnlinePassword);
    on<DeletePasswordEvent>(deletePassword);
-    on<GenerateAndSavePasswordTimeLimitEvent>(generateAndSavePasswordTimeLimited);
+    on<GenerateAndSavePasswordTimeLimitEvent>(
+        generateAndSavePasswordTimeLimited);
    on<GenerateAndSavePasswordOneTimeEvent>(generateAndSavePasswordOneTime);
    on<ToggleDaySelectionEvent>(toggleDaySelection);
    on<RenamePasswordEvent>(_renamePassword);
@ -59,7 +61,8 @@ class SmartDoorBloc extends Bloc<SmartDoorEvent, SmartDoorState> {
  List<OfflinePasswordModel>? oneTimePasswords = [];
  List<OfflinePasswordModel>? timeLimitPasswords = [];

-  Future generate7DigitNumber(GeneratePasswordEvent event, Emitter<SmartDoorState> emit) async {
+  Future generate7DigitNumber(
+      GeneratePasswordEvent event, Emitter<SmartDoorState> emit) async {
    emit(LoadingInitialState());
    passwordController.clear();
    Random random = Random();
@ -71,7 +74,8 @@ class SmartDoorBloc extends Bloc<SmartDoorEvent, SmartDoorState> {
  }

  Future generateAndSavePasswordOneTime(
-      GenerateAndSavePasswordOneTimeEvent event, Emitter<SmartDoorState> emit) async {
+      GenerateAndSavePasswordOneTimeEvent event,
+      Emitter<SmartDoorState> emit) async {
    try {
      if (isSavingPassword) return;
      isSavingPassword = true;
@ -92,7 +96,8 @@ class SmartDoorBloc extends Bloc<SmartDoorEvent, SmartDoorState> {
    }
  }

-  void _fetchSmartDoorStatus(InitialEvent event, Emitter<SmartDoorState> emit) async {
+  void _fetchSmartDoorStatus(
+      InitialEvent event, Emitter<SmartDoorState> emit) async {
    try {
      emit(LoadingInitialState());
      var response = await DevicesAPI.getDeviceStatus(deviceId);
@ -102,42 +107,63 @@ class SmartDoorBloc extends Bloc<SmartDoorEvent, SmartDoorState> {
      }
      deviceStatus = SmartDoorModel.fromJson(statusModelList);
      emit(UpdateState(smartDoorModel: deviceStatus));
-      // _listenToChanges();
+      _listenToChanges();
    } catch (e) {
      emit(FailedState(errorMessage: e.toString()));
      return;
    }
  }

-  _listenToChanges() {
+  StreamSubscription<DatabaseEvent>? _streamSubscription;
+  Timer? _timer;
+
+  void _listenToChanges() {
    try {
-      DatabaseReference ref = FirebaseDatabase.instance.ref('device-status/$deviceId');
+      _streamSubscription?.cancel();
+      DatabaseReference ref =
+          FirebaseDatabase.instance.ref('device-status/$deviceId');
      Stream<DatabaseEvent> stream = ref.onValue;

-      stream.listen((DatabaseEvent event) {
-        Map<dynamic, dynamic> usersMap = event.snapshot.value as Map<dynamic, dynamic>;
+      _streamSubscription = stream.listen((DatabaseEvent event) async {
+        if (_timer != null) {
+          await Future.delayed(const Duration(seconds: 2));
+        }
+        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']));
+          statusList
+              .add(StatusModel(code: element['code'], value: element['value']));
        });
-
        deviceStatus = SmartDoorModel.fromJson(statusList);
-        add(DoorLockUpdated());
+        if (!isClosed) {
+          add(DoorLockUpdated());
+        }
      });
    } catch (_) {}
  }

+  @override
+  Future<void> close() async {
+    _streamSubscription?.cancel();
+    _streamSubscription = null;
+    return super.close();
+  }
+ 
+
  _doorLockUpdated(DoorLockUpdated event, Emitter<SmartDoorState> emit) {
    unlockRequest = deviceStatus.unlockRequest;
    emit(UpdateState(smartDoorModel: deviceStatus));
  }

-  void _renamePassword(RenamePasswordEvent event, Emitter<SmartDoorState> emit) async {
+  void _renamePassword(
+      RenamePasswordEvent event, Emitter<SmartDoorState> emit) async {
    try {
      emit(LoadingInitialState());
      await DevicesAPI.renamePass(
-          name: passwordNameController.text, doorLockUuid: deviceId, passwordId: passwordId);
+          name: passwordNameController.text,
+          doorLockUuid: deviceId,
+          passwordId: passwordId);
      add(InitialOneTimePassword());
      add(InitialTimeLimitPassword());
      emit(UpdateState(smartDoorModel: deviceStatus));
@ -147,46 +173,58 @@ class SmartDoorBloc extends Bloc<SmartDoorEvent, SmartDoorState> {
    }
  }

-  void getTemporaryPasswords(InitialPasswordsPage event, Emitter<SmartDoorState> emit) async {
+  void getTemporaryPasswords(
+      InitialPasswordsPage event, Emitter<SmartDoorState> emit) async {
    try {
      emit(LoadingInitialState());
      var response = await DevicesAPI.getTemporaryPasswords(
        deviceId,
      );
      if (response is List) {
-        temporaryPasswords = response.map((item) => TemporaryPassword.fromJson(item)).toList();
-      } else if (response is Map && response.containsKey('data')) {
        temporaryPasswords =
-            (response['data'] as List).map((item) => TemporaryPassword.fromJson(item)).toList();
+            response.map((item) => TemporaryPassword.fromJson(item)).toList();
+      } else if (response is Map && response.containsKey('data')) {
+        temporaryPasswords = (response['data'] as List)
+            .map((item) => TemporaryPassword.fromJson(item))
+            .toList();
      }
-      emit(TemporaryPasswordsLoadedState(temporaryPassword: temporaryPasswords!));
+      emit(TemporaryPasswordsLoadedState(
+          temporaryPassword: temporaryPasswords!));
    } catch (e) {
      emit(FailedState(errorMessage: e.toString()));
    }
  }

-  void getOneTimePasswords(InitialOneTimePassword event, Emitter<SmartDoorState> emit) async {
+  void getOneTimePasswords(
+      InitialOneTimePassword event, Emitter<SmartDoorState> emit) async {
    try {
      emit(LoadingInitialState());
      var response = await DevicesAPI.getOneTimePasswords(deviceId);
      if (response is List) {
-        oneTimePasswords = response.map((item) => OfflinePasswordModel.fromJson(item)).toList();
+        oneTimePasswords = response
+            .map((item) => OfflinePasswordModel.fromJson(item))
+            .toList();
      }
-      emit(TemporaryPasswordsLoadedState(temporaryPassword: temporaryPasswords!));
+      emit(TemporaryPasswordsLoadedState(
+          temporaryPassword: temporaryPasswords!));
    } catch (e) {
      emit(FailedState(errorMessage: e.toString()));
    }
  }

-  void getTimeLimitPasswords(InitialTimeLimitPassword event, Emitter<SmartDoorState> emit) async {
+  void getTimeLimitPasswords(
+      InitialTimeLimitPassword event, Emitter<SmartDoorState> emit) async {
    try {
      emit(LoadingInitialState());
      var response = await DevicesAPI.getTimeLimitPasswords(deviceId);
      if (response is List) {
-        timeLimitPasswords = response.map((item) => OfflinePasswordModel.fromJson(item)).toList();
+        timeLimitPasswords = response
+            .map((item) => OfflinePasswordModel.fromJson(item))
+            .toList();
      }

-      emit(TemporaryPasswordsLoadedState(temporaryPassword: temporaryPasswords!));
+      emit(TemporaryPasswordsLoadedState(
+          temporaryPassword: temporaryPasswords!));
    } catch (e) {
      emit(FailedState(errorMessage: e.toString()));
    }
@ -207,7 +245,8 @@ class SmartDoorBloc extends Bloc<SmartDoorEvent, SmartDoorState> {
    return repeat;
  }

-  bool setStartEndTime(SetStartEndTimeEvent event, Emitter<SmartDoorState> emit) {
+  bool setStartEndTime(
+      SetStartEndTimeEvent event, Emitter<SmartDoorState> emit) {
    emit(LoadingInitialState());
    isStartEndTime = event.val;
    emit(IsStartEndState(isStartEndTime: isStartEndTime));
@ -230,7 +269,8 @@ class SmartDoorBloc extends Bloc<SmartDoorEvent, SmartDoorState> {
    emit(UpdateState(smartDoorModel: deviceStatus));
  }

-  Future<void> selectTimeOfLinePassword(SelectTimeEvent event, Emitter<SmartDoorState> emit) async {
+  Future<void> selectTimeOfLinePassword(
+      SelectTimeEvent event, Emitter<SmartDoorState> emit) async {
    emit(ChangeTimeState());
    final DateTime? picked = await showDatePicker(
      context: event.context,
@ -260,20 +300,27 @@ class SmartDoorBloc extends Bloc<SmartDoorEvent, SmartDoorState> {
            ).millisecondsSinceEpoch ~/
            1000; // Divide by 1000 to remove milliseconds
        if (event.isEffective) {
-          if (expirationTimeTimeStamp != null && selectedTimestamp > expirationTimeTimeStamp!) {
-            CustomSnackBar.displaySnackBar('Effective Time cannot be later than Expiration Time.');
+          if (expirationTimeTimeStamp != null &&
+              selectedTimestamp > expirationTimeTimeStamp!) {
+            CustomSnackBar.displaySnackBar(
+                'Effective Time cannot be later than Expiration Time.');
          } else {
-            effectiveTime =
-                selectedDateTime.toString().split('.').first; // Remove seconds and milliseconds
+            effectiveTime = selectedDateTime
+                .toString()
+                .split('.')
+                .first; // Remove seconds and milliseconds
            effectiveTimeTimeStamp = selectedTimestamp;
          }
        } else {
-          if (effectiveTimeTimeStamp != null && selectedTimestamp < effectiveTimeTimeStamp!) {
+          if (effectiveTimeTimeStamp != null &&
+              selectedTimestamp < effectiveTimeTimeStamp!) {
            CustomSnackBar.displaySnackBar(
                'Expiration Time cannot be earlier than Effective Time.');
          } else {
-            expirationTime =
-                selectedDateTime.toString().split('.').first; // Remove seconds and milliseconds
+            expirationTime = selectedDateTime
+                .toString()
+                .split('.')
+                .first; // Remove seconds and milliseconds
            expirationTimeTimeStamp = selectedTimestamp;
          }
        }
@ -329,20 +376,27 @@ class SmartDoorBloc extends Bloc<SmartDoorEvent, SmartDoorState> {
            ).millisecondsSinceEpoch ~/
            1000; // Divide by 1000 to remove milliseconds
        if (event.isEffective) {
-          if (expirationTimeTimeStamp != null && selectedTimestamp > expirationTimeTimeStamp!) {
-            CustomSnackBar.displaySnackBar('Effective Time cannot be later than Expiration Time.');
+          if (expirationTimeTimeStamp != null &&
+              selectedTimestamp > expirationTimeTimeStamp!) {
+            CustomSnackBar.displaySnackBar(
+                'Effective Time cannot be later than Expiration Time.');
          } else {
-            effectiveTime =
-                selectedDateTime.toString().split('.').first; // Remove seconds and milliseconds
+            effectiveTime = selectedDateTime
+                .toString()
+                .split('.')
+                .first; // Remove seconds and milliseconds
            effectiveTimeTimeStamp = selectedTimestamp;
          }
        } else {
-          if (effectiveTimeTimeStamp != null && selectedTimestamp < effectiveTimeTimeStamp!) {
+          if (effectiveTimeTimeStamp != null &&
+              selectedTimestamp < effectiveTimeTimeStamp!) {
            CustomSnackBar.displaySnackBar(
                'Expiration Time cannot be earlier than Effective Time.');
          } else {
-            expirationTime =
-                selectedDateTime.toString().split('.').first; // Remove seconds and milliseconds
+            expirationTime = selectedDateTime
+                .toString()
+                .split('.')
+                .first; // Remove seconds and milliseconds
            expirationTimeTimeStamp = selectedTimestamp;
          }
        }
@ -351,7 +405,8 @@ class SmartDoorBloc extends Bloc<SmartDoorEvent, SmartDoorState> {
    }
  }

-  Future<void> savePassword(SavePasswordEvent event, Emitter<SmartDoorState> emit) async {
+  Future<void> savePassword(
+      SavePasswordEvent event, Emitter<SmartDoorState> emit) async {
    if (_validateInputs() || isSavingPassword) return;
    try {
      isSavingPassword = true;
@ -381,7 +436,8 @@ class SmartDoorBloc extends Bloc<SmartDoorEvent, SmartDoorState> {
  }

  Future<void> generateAndSavePasswordTimeLimited(
-      GenerateAndSavePasswordTimeLimitEvent event, Emitter<SmartDoorState> emit) async {
+      GenerateAndSavePasswordTimeLimitEvent event,
+      Emitter<SmartDoorState> emit) async {
    if (timeLimitValidate() || isSavingPassword) return;
    try {
      isSavingPassword = true;
@ -407,10 +463,12 @@ class SmartDoorBloc extends Bloc<SmartDoorEvent, SmartDoorState> {
    }
  }

-  Future<void> deletePassword(DeletePasswordEvent event, Emitter<SmartDoorState> emit) async {
+  Future<void> deletePassword(
+      DeletePasswordEvent event, Emitter<SmartDoorState> emit) async {
    try {
      emit(LoadingInitialState());
-      await DevicesAPI.deletePassword(deviceId: deviceId, passwordId: event.passwordId)
+      await DevicesAPI.deletePassword(
+              deviceId: deviceId, passwordId: event.passwordId)
          .then((value) async {
        add(InitialPasswordsPage());
      });
@ -445,7 +503,8 @@ class SmartDoorBloc extends Bloc<SmartDoorEvent, SmartDoorState> {
    }

    if (repeat == true && (endTime == null || startTime == null)) {
-      CustomSnackBar.displaySnackBar('Start Time and End time and the days required ');
+      CustomSnackBar.displaySnackBar(
+          'Start Time and End time and the days required ');
      return true;
    }
    return false;
--- a/lib/features/devices/bloc/sos_bloc/sos_bloc.dart
+++ b/lib/features/devices/bloc/sos_bloc/sos_bloc.dart
@ -1,5 +1,6 @@
 import 'dart:async';
 import 'package:dio/dio.dart';
+import 'package:firebase_database/firebase_database.dart';
 import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:syncrow_app/features/app_layout/bloc/home_cubit.dart';
@ -173,6 +174,7 @@ class SosBloc extends Bloc<SosEvent, SosState> {
      );
      emit(UpdateState(sensor: deviceStatus));
      Future.delayed(const Duration(milliseconds: 500));
+      // _listenToChanges();
    } catch (e) {
      emit(SosFailedState(errorMessage: e.toString()));
      return;
@ -434,4 +436,39 @@ class SosBloc extends Bloc<SosEvent, SosState> {
      emit(SosFailedState(errorMessage: e.toString()));
    }
  }
+
+
+  //real-time db
+  // StreamSubscription<DatabaseEvent>? _streamSubscription;
+  // Timer? _timer;
+
+  // void _listenToChanges() {
+  //   try {
+  //     _streamSubscription?.cancel();
+  //     DatabaseReference ref =
+  //         FirebaseDatabase.instance.ref('device-status/$sosId');
+  //     Stream<DatabaseEvent> stream = ref.onValue;
+
+  //     _streamSubscription = stream.listen((DatabaseEvent event) async {
+  //       if (_timer != null) {
+  //         await Future.delayed(const Duration(seconds: 2));
+  //       }
+  //       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 = SosModel.fromJson(statusList);
+  //     });
+  //   } catch (_) {}
+  // }
+
+  // @override
+  // Future<void> close() async {
+  //   _streamSubscription?.cancel();
+  //   _streamSubscription = null;
+  //   return super.close();
+  // }
 }
--- a/lib/features/devices/bloc/three_gang_bloc/three_gang_bloc.dart
+++ b/lib/features/devices/bloc/three_gang_bloc/three_gang_bloc.dart
@ -31,7 +31,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
  List<GroupThreeGangModel> groupThreeGangList = [];
  bool allSwitchesOn = true;

-  ThreeGangBloc({required this.threeGangId, required this.switchCode}) : super(InitialState()) {
+  ThreeGangBloc({required this.threeGangId, required this.switchCode})
+      : super(InitialState()) {
    on<InitialEvent>(_fetchThreeGangStatus);
    on<ThreeGangUpdated>(_threeGangUpdated);
    on<ChangeFirstSwitchStatusEvent>(_changeFirstSwitch);
@ -57,7 +58,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
    on<ToggleCreateScheduleEvent>(toggleCreateSchedule);
  }

-  void _fetchThreeGangStatus(InitialEvent event, Emitter<ThreeGangState> emit) async {
+  void _fetchThreeGangStatus(
+      InitialEvent event, Emitter<ThreeGangState> emit) async {
    emit(LoadingInitialState());
    try {
      threeGangGroup = event.groupScreen;
@ -69,7 +71,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
            HomeCubit.getInstance().selectedSpace?.id ?? '', '3G');

        for (int i = 0; i < devicesList.length; i++) {
-          var response = await DevicesAPI.getDeviceStatus(devicesList[i].uuid ?? '');
+          var response =
+              await DevicesAPI.getDeviceStatus(devicesList[i].uuid ?? '');
          List<StatusModel> statusModelList = [];
          for (var status in response['status']) {
            statusModelList.add(StatusModel.fromJson(status));
@ -86,13 +89,16 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {

        if (groupThreeGangList.isNotEmpty) {
          groupThreeGangList.firstWhere((element) {
-            if (!element.firstSwitch || !element.secondSwitch || !element.thirdSwitch) {
+            if (!element.firstSwitch ||
+                !element.secondSwitch ||
+                !element.thirdSwitch) {
              allSwitchesOn = false;
            }
            return true;
          });
        }
-        emit(UpdateGroupState(threeGangList: groupThreeGangList, allSwitches: allSwitchesOn));
+        emit(UpdateGroupState(
+            threeGangList: groupThreeGangList, allSwitches: allSwitchesOn));
      } else {
        var response = await DevicesAPI.getDeviceStatus(threeGangId);
        List<StatusModel> statusModelList = [];
@ -101,7 +107,7 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
        }
        deviceStatus = ThreeGangModel.fromJson(statusModelList);
        emit(UpdateState(threeGangModel: deviceStatus));
-        // _listenToChanges();
+        _listenToChanges();
      }
    } catch (e) {
      emit(FailedState(error: e.toString()));
@ -109,22 +115,26 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
    }
  }

-  _listenToChanges() {
+  StreamSubscription<DatabaseEvent>? _streamSubscription;
+
+  void _listenToChanges() {
    try {
-      DatabaseReference ref = FirebaseDatabase.instance.ref('device-status/$threeGangId');
+      _streamSubscription?.cancel();
+      DatabaseReference ref =
+          FirebaseDatabase.instance.ref('device-status/$threeGangId');
      Stream<DatabaseEvent> stream = ref.onValue;

-      stream.listen((DatabaseEvent event) async {
+      _streamSubscription = stream.listen((DatabaseEvent event) async {
        if (_timer != null) {
-          await Future.delayed(const Duration(seconds: 2));
+          await Future.delayed(const Duration(seconds: 1));
        }
-        Map<dynamic, dynamic> usersMap = event.snapshot.value as Map<dynamic, dynamic>;
+        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']));
+          statusList
+              .add(StatusModel(code: element['code'], value: element['value']));
        });
-
        deviceStatus = ThreeGangModel.fromJson(statusList);
        if (!isClosed) {
          add(ThreeGangUpdated());
@ -133,11 +143,19 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
    } catch (_) {}
  }

+  @override
+  Future<void> close() async {
+    _streamSubscription?.cancel();
+    _streamSubscription = null;
+    return super.close();
+  }
+
  _threeGangUpdated(ThreeGangUpdated event, Emitter<ThreeGangState> emit) {
    emit(UpdateState(threeGangModel: deviceStatus));
  }

-  void _changeFirstSwitch(ChangeFirstSwitchStatusEvent event, Emitter<ThreeGangState> emit) async {
+  void _changeFirstSwitch(
+      ChangeFirstSwitchStatusEvent event, Emitter<ThreeGangState> emit) async {
    emit(LoadingNewSate(threeGangModel: deviceStatus));
    try {
      if (threeGangGroup) {
@ -146,11 +164,14 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
          if (element.deviceId == event.deviceId) {
            element.firstSwitch = !event.value;
          }
-          if (!element.firstSwitch || !element.secondSwitch || !element.thirdSwitch) {
+          if (!element.firstSwitch ||
+              !element.secondSwitch ||
+              !element.thirdSwitch) {
            allSwitchesValue = false;
          }
        });
-        emit(UpdateGroupState(threeGangList: groupThreeGangList, allSwitches: allSwitchesValue));
+        emit(UpdateGroupState(
+            threeGangList: groupThreeGangList, allSwitches: allSwitchesValue));
      } else {
        deviceStatus.firstSwitch = !event.value;
        emit(UpdateState(threeGangModel: deviceStatus));
@ -187,11 +208,14 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
          if (element.deviceId == event.deviceId) {
            element.secondSwitch = !event.value;
          }
-          if (!element.firstSwitch || !element.secondSwitch || !element.thirdSwitch) {
+          if (!element.firstSwitch ||
+              !element.secondSwitch ||
+              !element.thirdSwitch) {
            allSwitchesValue = false;
          }
        });
-        emit(UpdateGroupState(threeGangList: groupThreeGangList, allSwitches: allSwitchesValue));
+        emit(UpdateGroupState(
+            threeGangList: groupThreeGangList, allSwitches: allSwitchesValue));
      } else {
        deviceStatus.secondSwitch = !event.value;
        emit(UpdateState(threeGangModel: deviceStatus));
@ -217,7 +241,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
    }
  }

-  void _changeThirdSwitch(ChangeThirdSwitchStatusEvent event, Emitter<ThreeGangState> emit) async {
+  void _changeThirdSwitch(
+      ChangeThirdSwitchStatusEvent event, Emitter<ThreeGangState> emit) async {
    emit(LoadingNewSate(threeGangModel: deviceStatus));
    try {
      if (threeGangGroup) {
@ -226,11 +251,14 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
          if (element.deviceId == event.deviceId) {
            element.thirdSwitch = !event.value;
          }
-          if (!element.firstSwitch || !element.secondSwitch || !element.thirdSwitch) {
+          if (!element.firstSwitch ||
+              !element.secondSwitch ||
+              !element.thirdSwitch) {
            allSwitchesValue = false;
          }
        });
-        emit(UpdateGroupState(threeGangList: groupThreeGangList, allSwitches: allSwitchesValue));
+        emit(UpdateGroupState(
+            threeGangList: groupThreeGangList, allSwitches: allSwitchesValue));
      } else {
        deviceStatus.thirdSwitch = !event.value;
        emit(UpdateState(threeGangModel: deviceStatus));
@ -269,15 +297,21 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
      final response = await Future.wait([
        DevicesAPI.controlDevice(
            DeviceControlModel(
-                deviceId: threeGangId, code: 'switch_1', value: deviceStatus.firstSwitch),
+                deviceId: threeGangId,
+                code: 'switch_1',
+                value: deviceStatus.firstSwitch),
            threeGangId),
        DevicesAPI.controlDevice(
            DeviceControlModel(
-                deviceId: threeGangId, code: 'switch_2', value: deviceStatus.secondSwitch),
+                deviceId: threeGangId,
+                code: 'switch_2',
+                value: deviceStatus.secondSwitch),
            threeGangId),
        DevicesAPI.controlDevice(
            DeviceControlModel(
-                deviceId: threeGangId, code: 'switch_3', value: deviceStatus.thirdSwitch),
+                deviceId: threeGangId,
+                code: 'switch_3',
+                value: deviceStatus.thirdSwitch),
            threeGangId),
      ]);

@ -303,15 +337,21 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
      final response = await Future.wait([
        DevicesAPI.controlDevice(
            DeviceControlModel(
-                deviceId: threeGangId, code: 'switch_1', value: deviceStatus.firstSwitch),
+                deviceId: threeGangId,
+                code: 'switch_1',
+                value: deviceStatus.firstSwitch),
            threeGangId),
        DevicesAPI.controlDevice(
            DeviceControlModel(
-                deviceId: threeGangId, code: 'switch_2', value: deviceStatus.secondSwitch),
+                deviceId: threeGangId,
+                code: 'switch_2',
+                value: deviceStatus.secondSwitch),
            threeGangId),
        DevicesAPI.controlDevice(
            DeviceControlModel(
-                deviceId: threeGangId, code: 'switch_3', value: deviceStatus.thirdSwitch),
+                deviceId: threeGangId,
+                code: 'switch_3',
+                value: deviceStatus.thirdSwitch),
            threeGangId),
      ]);

@ -333,9 +373,11 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
        groupThreeGangList[i].secondSwitch = true;
        groupThreeGangList[i].thirdSwitch = true;
      }
-      emit(UpdateGroupState(threeGangList: groupThreeGangList, allSwitches: true));
+      emit(UpdateGroupState(
+          threeGangList: groupThreeGangList, allSwitches: true));

-      List<String> allDeviceIds = groupThreeGangList.map((device) => device.deviceId).toList();
+      List<String> allDeviceIds =
+          groupThreeGangList.map((device) => device.deviceId).toList();

      final response1 = await DevicesAPI.deviceBatchController(
        code: 'switch_1',
@ -365,7 +407,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
    }
  }

-  void _groupAllOff(GroupAllOffEvent event, Emitter<ThreeGangState> emit) async {
+  void _groupAllOff(
+      GroupAllOffEvent event, Emitter<ThreeGangState> emit) async {
    emit(LoadingNewSate(threeGangModel: deviceStatus));
    try {
      for (int i = 0; i < groupThreeGangList.length; i++) {
@ -373,8 +416,10 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
        groupThreeGangList[i].secondSwitch = false;
        groupThreeGangList[i].thirdSwitch = false;
      }
-      emit(UpdateGroupState(threeGangList: groupThreeGangList, allSwitches: false));
-      List<String> allDeviceIds = groupThreeGangList.map((device) => device.deviceId).toList();
+      emit(UpdateGroupState(
+          threeGangList: groupThreeGangList, allSwitches: false));
+      List<String> allDeviceIds =
+          groupThreeGangList.map((device) => device.deviceId).toList();

      final response1 = await DevicesAPI.deviceBatchController(
        code: 'switch_1',
@ -404,17 +449,20 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
    }
  }

-  void _changeSliding(ChangeSlidingSegment event, Emitter<ThreeGangState> emit) async {
+  void _changeSliding(
+      ChangeSlidingSegment event, Emitter<ThreeGangState> emit) async {
    emit(ChangeSlidingSegmentState(value: event.value));
  }

-  void _setCounterValue(SetCounterValue event, Emitter<ThreeGangState> emit) async {
+  void _setCounterValue(
+      SetCounterValue event, Emitter<ThreeGangState> emit) async {
    emit(LoadingNewSate(threeGangModel: deviceStatus));
    int seconds = 0;
    try {
      seconds = event.duration.inSeconds;
      final response = await DevicesAPI.controlDevice(
-          DeviceControlModel(deviceId: threeGangId, code: event.deviceCode, value: seconds),
+          DeviceControlModel(
+              deviceId: threeGangId, code: event.deviceCode, value: seconds),
          threeGangId);

      if (response['success'] ?? false) {
@ -441,7 +489,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
    }
  }

-  void _getCounterValue(GetCounterEvent event, Emitter<ThreeGangState> emit) async {
+  void _getCounterValue(
+      GetCounterEvent event, Emitter<ThreeGangState> emit) async {
    emit(LoadingInitialState());
    try {
      var response = await DevicesAPI.getDeviceStatus(threeGangId);
@ -551,7 +600,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
        deviceId: threeGangId,
      );
      List<dynamic> jsonData = response;
-      listSchedule = jsonData.map((item) => ScheduleModel.fromJson(item)).toList();
+      listSchedule =
+          jsonData.map((item) => ScheduleModel.fromJson(item)).toList();
      emit(InitialState());
    } on DioException catch (e) {
      final errorData = e.response!.data;
@ -562,12 +612,13 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {

  int? getTimeStampWithoutSeconds(DateTime? dateTime) {
    if (dateTime == null) return null;
-    DateTime dateTimeWithoutSeconds =
-        DateTime(dateTime.year, dateTime.month, dateTime.day, dateTime.hour, dateTime.minute);
+    DateTime dateTimeWithoutSeconds = DateTime(dateTime.year, dateTime.month,
+        dateTime.day, dateTime.hour, dateTime.minute);
    return dateTimeWithoutSeconds.millisecondsSinceEpoch ~/ 1000;
  }

-  Future toggleChange(ToggleScheduleEvent event, Emitter<ThreeGangState> emit) async {
+  Future toggleChange(
+      ToggleScheduleEvent event, Emitter<ThreeGangState> emit) async {
    try {
      emit(LoadingInitialState());
      final response = await DevicesAPI.changeSchedule(
@ -586,7 +637,8 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
    }
  }

-  Future deleteSchedule(DeleteScheduleEvent event, Emitter<ThreeGangState> emit) async {
+  Future deleteSchedule(
+      DeleteScheduleEvent event, Emitter<ThreeGangState> emit) async {
    try {
      emit(LoadingInitialState());
      final response = await DevicesAPI.deleteSchedule(
@ -606,13 +658,15 @@ class ThreeGangBloc extends Bloc<ThreeGangEvent, ThreeGangState> {
    }
  }

-  void toggleSelectedIndex(ToggleSelectedEvent event, Emitter<ThreeGangState> emit) {
+  void toggleSelectedIndex(
+      ToggleSelectedEvent event, Emitter<ThreeGangState> emit) {
    emit(LoadingInitialState());
    selectedTabIndex = event.index;
    emit(ChangeSlidingSegmentState(value: selectedTabIndex));
  }

-  void toggleCreateSchedule(ToggleCreateScheduleEvent event, Emitter<ThreeGangState> emit) {
+  void toggleCreateSchedule(
+      ToggleCreateScheduleEvent event, Emitter<ThreeGangState> emit) {
    emit(LoadingInitialState());
    createSchedule = !createSchedule;
    selectedDays.clear();
--- a/lib/features/devices/bloc/three_touch_bloc/three_touch_bloc.dart
+++ b/lib/features/devices/bloc/three_touch_bloc/three_touch_bloc.dart
@ -38,7 +38,8 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
  List<GroupThreeTouchModel> groupThreeTouchList = [];
  bool allSwitchesOn = true;

-  ThreeTouchBloc({required this.threeTouchId, required this.switchCode}) : super(InitialState()) {
+  ThreeTouchBloc({required this.threeTouchId, required this.switchCode})
+      : super(InitialState()) {
    on<InitialEvent>(_fetchThreeTouchStatus);
    on<ThreeTouchUpdated>(_threeTouchUpdated);
    on<ChangeFirstSwitchStatusEvent>(_changeFirstSwitch);
@ -63,7 +64,8 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
    on<ChangeStatusEvent>(_changeStatus);
  }

-  void _fetchThreeTouchStatus(InitialEvent event, Emitter<ThreeTouchState> emit) async {
+  void _fetchThreeTouchStatus(
+      InitialEvent event, Emitter<ThreeTouchState> emit) async {
    emit(LoadingInitialState());
    try {
      threeTouchGroup = event.groupScreen;
@ -75,7 +77,8 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
            HomeCubit.getInstance().selectedSpace?.id ?? '', '3GT');

        for (int i = 0; i < devicesList.length; i++) {
-          var response = await DevicesAPI.getDeviceStatus(devicesList[i].uuid ?? '');
+          var response =
+              await DevicesAPI.getDeviceStatus(devicesList[i].uuid ?? '');
          List<StatusModel> statusModelList = [];
          for (var status in response['status']) {
            statusModelList.add(StatusModel.fromJson(status));
@ -92,13 +95,16 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {

        if (groupThreeTouchList.isNotEmpty) {
          groupThreeTouchList.firstWhere((element) {
-            if (!element.firstSwitch || !element.secondSwitch || !element.thirdSwitch) {
+            if (!element.firstSwitch ||
+                !element.secondSwitch ||
+                !element.thirdSwitch) {
              allSwitchesOn = false;
            }
            return true;
          });
        }
-        emit(UpdateGroupState(threeTouchList: groupThreeTouchList, allSwitches: allSwitchesOn));
+        emit(UpdateGroupState(
+            threeTouchList: groupThreeTouchList, allSwitches: allSwitchesOn));
      } else {
        var response = await DevicesAPI.getDeviceStatus(threeTouchId);
        List<StatusModel> statusModelList = [];
@ -107,7 +113,7 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
        }
        deviceStatus = ThreeTouchModel.fromJson(statusModelList);
        emit(UpdateState(threeTouchModel: deviceStatus));
-        // _listenToChanges();
+        _listenToChanges();
      }
    } catch (e) {
      emit(FailedState(error: e.toString()));
@ -117,18 +123,21 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {

  _listenToChanges() {
    try {
-      DatabaseReference ref = FirebaseDatabase.instance.ref('device-status/$threeTouchId');
+      DatabaseReference ref =
+          FirebaseDatabase.instance.ref('device-status/$threeTouchId');
      Stream<DatabaseEvent> stream = ref.onValue;

      stream.listen((DatabaseEvent event) async {
        if (_timer != null) {
          await Future.delayed(const Duration(seconds: 2));
        }
-        Map<dynamic, dynamic> usersMap = event.snapshot.value as Map<dynamic, dynamic>;
+        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']));
+          statusList
+              .add(StatusModel(code: element['code'], value: element['value']));
        });

        deviceStatus = ThreeTouchModel.fromJson(statusList);
@ -143,7 +152,8 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
    emit(UpdateState(threeTouchModel: deviceStatus));
  }

-  void _changeFirstSwitch(ChangeFirstSwitchStatusEvent event, Emitter<ThreeTouchState> emit) async {
+  void _changeFirstSwitch(
+      ChangeFirstSwitchStatusEvent event, Emitter<ThreeTouchState> emit) async {
    emit(LoadingNewSate(threeTouchModel: deviceStatus));
    try {
      if (threeTouchGroup) {
@ -152,11 +162,15 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
          if (element.deviceId == event.deviceId) {
            element.firstSwitch = !event.value;
          }
-          if (!element.firstSwitch || !element.secondSwitch || !element.thirdSwitch) {
+          if (!element.firstSwitch ||
+              !element.secondSwitch ||
+              !element.thirdSwitch) {
            allSwitchesValue = false;
          }
        });
-        emit(UpdateGroupState(threeTouchList: groupThreeTouchList, allSwitches: allSwitchesValue));
+        emit(UpdateGroupState(
+            threeTouchList: groupThreeTouchList,
+            allSwitches: allSwitchesValue));
      } else {
        deviceStatus.firstSwitch = !event.value;
        emit(UpdateState(threeTouchModel: deviceStatus));
@ -183,8 +197,8 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
    }
  }

-  void _changeSecondSwitch(
-      ChangeSecondSwitchStatusEvent event, Emitter<ThreeTouchState> emit) async {
+  void _changeSecondSwitch(ChangeSecondSwitchStatusEvent event,
+      Emitter<ThreeTouchState> emit) async {
    emit(LoadingNewSate(threeTouchModel: deviceStatus));
    try {
      if (threeTouchGroup) {
@ -193,11 +207,15 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
          if (element.deviceId == event.deviceId) {
            element.secondSwitch = !event.value;
          }
-          if (!element.firstSwitch || !element.secondSwitch || !element.thirdSwitch) {
+          if (!element.firstSwitch ||
+              !element.secondSwitch ||
+              !element.thirdSwitch) {
            allSwitchesValue = false;
          }
        });
-        emit(UpdateGroupState(threeTouchList: groupThreeTouchList, allSwitches: allSwitchesValue));
+        emit(UpdateGroupState(
+            threeTouchList: groupThreeTouchList,
+            allSwitches: allSwitchesValue));
      } else {
        deviceStatus.secondSwitch = !event.value;
        emit(UpdateState(threeTouchModel: deviceStatus));
@ -223,7 +241,8 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
    }
  }

-  void _changeThirdSwitch(ChangeThirdSwitchStatusEvent event, Emitter<ThreeTouchState> emit) async {
+  void _changeThirdSwitch(
+      ChangeThirdSwitchStatusEvent event, Emitter<ThreeTouchState> emit) async {
    emit(LoadingNewSate(threeTouchModel: deviceStatus));
    try {
      if (threeTouchGroup) {
@ -232,11 +251,15 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
          if (element.deviceId == event.deviceId) {
            element.thirdSwitch = !event.value;
          }
-          if (!element.firstSwitch || !element.secondSwitch || !element.thirdSwitch) {
+          if (!element.firstSwitch ||
+              !element.secondSwitch ||
+              !element.thirdSwitch) {
            allSwitchesValue = false;
          }
        });
-        emit(UpdateGroupState(threeTouchList: groupThreeTouchList, allSwitches: allSwitchesValue));
+        emit(UpdateGroupState(
+            threeTouchList: groupThreeTouchList,
+            allSwitches: allSwitchesValue));
      } else {
        deviceStatus.thirdSwitch = !event.value;
        emit(UpdateState(threeTouchModel: deviceStatus));
@ -275,15 +298,21 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
      final response = await Future.wait([
        DevicesAPI.controlDevice(
            DeviceControlModel(
-                deviceId: threeTouchId, code: 'switch_1', value: deviceStatus.firstSwitch),
+                deviceId: threeTouchId,
+                code: 'switch_1',
+                value: deviceStatus.firstSwitch),
            threeTouchId),
        DevicesAPI.controlDevice(
            DeviceControlModel(
-                deviceId: threeTouchId, code: 'switch_2', value: deviceStatus.secondSwitch),
+                deviceId: threeTouchId,
+                code: 'switch_2',
+                value: deviceStatus.secondSwitch),
            threeTouchId),
        DevicesAPI.controlDevice(
            DeviceControlModel(
-                deviceId: threeTouchId, code: 'switch_3', value: deviceStatus.thirdSwitch),
+                deviceId: threeTouchId,
+                code: 'switch_3',
+                value: deviceStatus.thirdSwitch),
            threeTouchId),
      ]);

@ -309,15 +338,21 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
      final response = await Future.wait([
        DevicesAPI.controlDevice(
            DeviceControlModel(
-                deviceId: threeTouchId, code: 'switch_1', value: deviceStatus.firstSwitch),
+                deviceId: threeTouchId,
+                code: 'switch_1',
+                value: deviceStatus.firstSwitch),
            threeTouchId),
        DevicesAPI.controlDevice(
            DeviceControlModel(
-                deviceId: threeTouchId, code: 'switch_2', value: deviceStatus.secondSwitch),
+                deviceId: threeTouchId,
+                code: 'switch_2',
+                value: deviceStatus.secondSwitch),
            threeTouchId),
        DevicesAPI.controlDevice(
            DeviceControlModel(
-                deviceId: threeTouchId, code: 'switch_3', value: deviceStatus.thirdSwitch),
+                deviceId: threeTouchId,
+                code: 'switch_3',
+                value: deviceStatus.thirdSwitch),
            threeTouchId),
      ]);

@ -339,8 +374,10 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
        groupThreeTouchList[i].secondSwitch = true;
        groupThreeTouchList[i].thirdSwitch = true;
      }
-      emit(UpdateGroupState(threeTouchList: groupThreeTouchList, allSwitches: true));
-      List<String> allDeviceIds = groupThreeTouchList.map((device) => device.deviceId).toList();
+      emit(UpdateGroupState(
+          threeTouchList: groupThreeTouchList, allSwitches: true));
+      List<String> allDeviceIds =
+          groupThreeTouchList.map((device) => device.deviceId).toList();
      final response1 = await DevicesAPI.deviceBatchController(
        code: 'switch_1',
        devicesUuid: allDeviceIds,
@ -369,7 +406,8 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
    }
  }

-  void _groupAllOff(GroupAllOffEvent event, Emitter<ThreeTouchState> emit) async {
+  void _groupAllOff(
+      GroupAllOffEvent event, Emitter<ThreeTouchState> emit) async {
    emit(LoadingNewSate(threeTouchModel: deviceStatus));
    try {
      for (int i = 0; i < groupThreeTouchList.length; i++) {
@ -377,8 +415,10 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
        groupThreeTouchList[i].secondSwitch = false;
        groupThreeTouchList[i].thirdSwitch = false;
      }
-      List<String> allDeviceIds = groupThreeTouchList.map((device) => device.deviceId).toList();
-      emit(UpdateGroupState(threeTouchList: groupThreeTouchList, allSwitches: false));
+      List<String> allDeviceIds =
+          groupThreeTouchList.map((device) => device.deviceId).toList();
+      emit(UpdateGroupState(
+          threeTouchList: groupThreeTouchList, allSwitches: false));
      final response1 = await DevicesAPI.deviceBatchController(
        code: 'switch_1',
        devicesUuid: allDeviceIds,
@ -407,17 +447,20 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
    }
  }

-  void _changeSliding(ChangeSlidingSegment event, Emitter<ThreeTouchState> emit) async {
+  void _changeSliding(
+      ChangeSlidingSegment event, Emitter<ThreeTouchState> emit) async {
    emit(ChangeSlidingSegmentState(value: event.value));
  }

-  void _setCounterValue(SetCounterValue event, Emitter<ThreeTouchState> emit) async {
+  void _setCounterValue(
+      SetCounterValue event, Emitter<ThreeTouchState> emit) async {
    emit(LoadingNewSate(threeTouchModel: deviceStatus));
    int seconds = 0;
    try {
      seconds = event.duration.inSeconds;
      final response = await DevicesAPI.controlDevice(
-          DeviceControlModel(deviceId: threeTouchId, code: event.deviceCode, value: seconds),
+          DeviceControlModel(
+              deviceId: threeTouchId, code: event.deviceCode, value: seconds),
          threeTouchId);

      if (response['success'] ?? false) {
@ -444,7 +487,8 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
    }
  }

-  void _getCounterValue(GetCounterEvent event, Emitter<ThreeTouchState> emit) async {
+  void _getCounterValue(
+      GetCounterEvent event, Emitter<ThreeTouchState> emit) async {
    emit(LoadingInitialState());
    try {
      var response = await DevicesAPI.getDeviceStatus(threeTouchId);
@ -554,7 +598,8 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
        deviceId: threeTouchId,
      );
      List<dynamic> jsonData = response;
-      listSchedule = jsonData.map((item) => ScheduleModel.fromJson(item)).toList();
+      listSchedule =
+          jsonData.map((item) => ScheduleModel.fromJson(item)).toList();
      emit(InitialState());
    } on DioException catch (e) {
      final errorData = e.response!.data;
@ -565,12 +610,13 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {

  int? getTimeStampWithoutSeconds(DateTime? dateTime) {
    if (dateTime == null) return null;
-    DateTime dateTimeWithoutSeconds =
-        DateTime(dateTime.year, dateTime.month, dateTime.day, dateTime.hour, dateTime.minute);
+    DateTime dateTimeWithoutSeconds = DateTime(dateTime.year, dateTime.month,
+        dateTime.day, dateTime.hour, dateTime.minute);
    return dateTimeWithoutSeconds.millisecondsSinceEpoch ~/ 1000;
  }

-  Future toggleChange(ToggleScheduleEvent event, Emitter<ThreeTouchState> emit) async {
+  Future toggleChange(
+      ToggleScheduleEvent event, Emitter<ThreeTouchState> emit) async {
    try {
      emit(LoadingInitialState());
      final response = await DevicesAPI.changeSchedule(
@ -589,7 +635,8 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
    }
  }

-  Future deleteSchedule(DeleteScheduleEvent event, Emitter<ThreeTouchState> emit) async {
+  Future deleteSchedule(
+      DeleteScheduleEvent event, Emitter<ThreeTouchState> emit) async {
    try {
      emit(LoadingInitialState());
      final response = await DevicesAPI.deleteSchedule(
@ -609,13 +656,15 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
    }
  }

-  void toggleSelectedIndex(ToggleSelectedEvent event, Emitter<ThreeTouchState> emit) {
+  void toggleSelectedIndex(
+      ToggleSelectedEvent event, Emitter<ThreeTouchState> emit) {
    emit(LoadingInitialState());
    selectedTabIndex = event.index;
    emit(ChangeSlidingSegmentState(value: selectedTabIndex));
  }

-  void toggleCreateSchedule(ToggleCreateScheduleEvent event, Emitter<ThreeTouchState> emit) {
+  void toggleCreateSchedule(
+      ToggleCreateScheduleEvent event, Emitter<ThreeTouchState> emit) {
    emit(LoadingInitialState());
    createSchedule = !createSchedule;
    selectedDays.clear();
@ -633,7 +682,8 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
  String statusSelected = '';
  String optionSelected = '';

-  Future<void> _changeStatus(ChangeStatusEvent event, Emitter<ThreeTouchState> emit) async {
+  Future<void> _changeStatus(
+      ChangeStatusEvent event, Emitter<ThreeTouchState> emit) async {
    try {
      emit(LoadingInitialState());
      final Map<String, Map<String, String>> controlMap = {
@ -667,11 +717,15 @@ class ThreeTouchBloc extends Bloc<ThreeTouchEvent, ThreeTouchState> {
      final selectedControl = controlMap[optionSelected]?[statusSelected];
      if (selectedControl != null) {
        await DevicesAPI.controlDevice(
-          DeviceControlModel(deviceId: threeTouchId, code: optionSelected, value: selectedControl),
+          DeviceControlModel(
+              deviceId: threeTouchId,
+              code: optionSelected,
+              value: selectedControl),
          threeTouchId,
        );
      } else {
-        emit(const FailedState(error: 'Invalid statusSelected or optionSelected'));
+        emit(const FailedState(
+            error: 'Invalid statusSelected or optionSelected'));
      }
    } on DioException catch (e) {
      final errorData = e.response!.data;
--- a/lib/features/devices/bloc/two_gang_bloc/two_gang_bloc.dart
+++ b/lib/features/devices/bloc/two_gang_bloc/two_gang_bloc.dart
@ -35,7 +35,8 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
  bool createSchedule = false;
  List<ScheduleModel> listSchedule = [];

-  TwoGangBloc({required this.twoGangId, required this.switchCode}) : super(InitialState()) {
+  TwoGangBloc({required this.twoGangId, required this.switchCode})
+      : super(InitialState()) {
    on<InitialEvent>(_fetchTwoGangStatus);
    on<TwoGangUpdated>(_twoGangUpdated);
    on<ChangeFirstSwitchStatusEvent>(_changeFirstSwitch);
@ -65,13 +66,15 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {

  int selectedTabIndex = 0;

-  void toggleSelectedIndex(ToggleSelectedEvent event, Emitter<TwoGangState> emit) {
+  void toggleSelectedIndex(
+      ToggleSelectedEvent event, Emitter<TwoGangState> emit) {
    emit(LoadingInitialState());
    selectedTabIndex = event.index;
    emit(ChangeSlidingSegmentState(value: selectedTabIndex));
  }

-  void toggleCreateSchedule(ToggleCreateScheduleEvent event, Emitter<TwoGangState> emit) {
+  void toggleCreateSchedule(
+      ToggleCreateScheduleEvent event, Emitter<TwoGangState> emit) {
    emit(LoadingInitialState());
    createSchedule = !createSchedule;
    selectedDays.clear();
@ -79,7 +82,8 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
    emit(UpdateCreateScheduleState(createSchedule));
  }

-  void _fetchTwoGangStatus(InitialEvent event, Emitter<TwoGangState> emit) async {
+  void _fetchTwoGangStatus(
+      InitialEvent event, Emitter<TwoGangState> emit) async {
    emit(LoadingInitialState());
    try {
      var response = await DevicesAPI.getDeviceStatus(twoGangId);
@ -89,42 +93,50 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
      }
      deviceStatus = TwoGangModel.fromJson(statusModelList);
      emit(UpdateState(twoGangModel: deviceStatus));
-      // _listenToChanges();
+      _listenToChanges(twoGangId);
    } catch (e) {
      emit(FailedState(error: e.toString()));
      return;
    }
  }

-  _listenToChanges() {
+  StreamSubscription<DatabaseEvent>? _streamSubscription;
+  void _listenToChanges(String id) {
    try {
-      DatabaseReference ref = FirebaseDatabase.instance.ref('device-status/$twoGangId');
+      _streamSubscription?.cancel();
+      DatabaseReference ref =
+          FirebaseDatabase.instance.ref('device-status/$id');
      Stream<DatabaseEvent> stream = ref.onValue;
-
-      stream.listen((DatabaseEvent event) async {
-        if (_timer != null) {
-          await Future.delayed(const Duration(seconds: 2));
-        }
-        Map<dynamic, dynamic> usersMap = event.snapshot.value as Map<dynamic, dynamic>;
+      _streamSubscription = stream.listen((DatabaseEvent event) {
+        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']));
+          statusList
+              .add(StatusModel(code: element['code'], value: element['value']));
        });
-
        deviceStatus = TwoGangModel.fromJson(statusList);
-        if (!isClosed) {
-          add(TwoGangUpdated());
-        }
+        add(TwoGangUpdated());
      });
    } catch (_) {}
  }

+  @override
+  Future<void> close() async {
+    _streamSubscription?.cancel();
+    _streamSubscription = null;
+    return super.close();
+  }
+
  _twoGangUpdated(TwoGangUpdated event, Emitter<TwoGangState> emit) {
+    emit(LoadingNewSate(twoGangModel: deviceStatus));
+
    emit(UpdateState(twoGangModel: deviceStatus));
  }

-  void _changeFirstSwitch(ChangeFirstSwitchStatusEvent event, Emitter<TwoGangState> emit) async {
+  void _changeFirstSwitch(
+      ChangeFirstSwitchStatusEvent event, Emitter<TwoGangState> emit) async {
    emit(LoadingNewSate(twoGangModel: deviceStatus));
    try {
      deviceStatus.firstSwitch = !event.value;
@ -135,7 +147,8 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {

      _timer = Timer(const Duration(milliseconds: 100), () async {
        final response = await DevicesAPI.controlDevice(
-            DeviceControlModel(deviceId: twoGangId, code: 'switch_1', value: !event.value),
+            DeviceControlModel(
+                deviceId: twoGangId, code: 'switch_1', value: !event.value),
            twoGangId);

        if (!response['success']) {
@ -147,7 +160,8 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
    }
  }

-  void _changeSecondSwitch(ChangeSecondSwitchStatusEvent event, Emitter<TwoGangState> emit) async {
+  void _changeSecondSwitch(
+      ChangeSecondSwitchStatusEvent event, Emitter<TwoGangState> emit) async {
    emit(LoadingNewSate(twoGangModel: deviceStatus));
    try {
      deviceStatus.secondSwitch = !event.value;
@ -157,7 +171,8 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
      }
      _timer = Timer(const Duration(milliseconds: 100), () async {
        final response = await DevicesAPI.controlDevice(
-            DeviceControlModel(deviceId: twoGangId, code: 'switch_2', value: !event.value),
+            DeviceControlModel(
+                deviceId: twoGangId, code: 'switch_2', value: !event.value),
            twoGangId);

        if (!response['success']) {
@ -180,11 +195,15 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
      final response = await Future.wait([
        DevicesAPI.controlDevice(
            DeviceControlModel(
-                deviceId: twoGangId, code: 'switch_1', value: deviceStatus.firstSwitch),
+                deviceId: twoGangId,
+                code: 'switch_1',
+                value: deviceStatus.firstSwitch),
            twoGangId),
        DevicesAPI.controlDevice(
            DeviceControlModel(
-                deviceId: twoGangId, code: 'switch_2', value: deviceStatus.secondSwitch),
+                deviceId: twoGangId,
+                code: 'switch_2',
+                value: deviceStatus.secondSwitch),
            twoGangId),
      ]);

@ -207,11 +226,15 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
      final response = await Future.wait([
        DevicesAPI.controlDevice(
            DeviceControlModel(
-                deviceId: twoGangId, code: 'switch_1', value: deviceStatus.firstSwitch),
+                deviceId: twoGangId,
+                code: 'switch_1',
+                value: deviceStatus.firstSwitch),
            twoGangId),
        DevicesAPI.controlDevice(
            DeviceControlModel(
-                deviceId: twoGangId, code: 'switch_2', value: deviceStatus.secondSwitch),
+                deviceId: twoGangId,
+                code: 'switch_2',
+                value: deviceStatus.secondSwitch),
            twoGangId),
      ]);
      if (response.every((element) => !element['success'])) {
@ -232,7 +255,8 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
        groupTwoGangList[i].secondSwitch = true;
      }
      emit(UpdateGroupState(twoGangList: groupTwoGangList, allSwitches: true));
-      List<String> allDeviceIds = groupTwoGangList.map((device) => device.deviceId).toList();
+      List<String> allDeviceIds =
+          groupTwoGangList.map((device) => device.deviceId).toList();

      final response1 = await DevicesAPI.deviceBatchController(
        code: 'switch_1',
@ -267,7 +291,8 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {

      emit(UpdateGroupState(twoGangList: groupTwoGangList, allSwitches: false));

-      List<String> allDeviceIds = groupTwoGangList.map((device) => device.deviceId).toList();
+      List<String> allDeviceIds =
+          groupTwoGangList.map((device) => device.deviceId).toList();

      final response1 = await DevicesAPI.deviceBatchController(
        code: 'switch_1',
@ -292,17 +317,20 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
    }
  }

-  void _changeSliding(ChangeSlidingSegment event, Emitter<TwoGangState> emit) async {
+  void _changeSliding(
+      ChangeSlidingSegment event, Emitter<TwoGangState> emit) async {
    emit(ChangeSlidingSegmentState(value: event.value));
  }

-  void _setCounterValue(SetCounterValue event, Emitter<TwoGangState> emit) async {
+  void _setCounterValue(
+      SetCounterValue event, Emitter<TwoGangState> emit) async {
    emit(LoadingNewSate(twoGangModel: deviceStatus));
    int seconds = 0;
    try {
      seconds = event.duration.inSeconds;
      final response = await DevicesAPI.controlDevice(
-          DeviceControlModel(deviceId: twoGangId, code: event.deviceCode, value: seconds),
+          DeviceControlModel(
+              deviceId: twoGangId, code: event.deviceCode, value: seconds),
          twoGangId);

      if (response['success'] ?? false) {
@ -327,7 +355,8 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
    }
  }

-  void _getCounterValue(GetCounterEvent event, Emitter<TwoGangState> emit) async {
+  void _getCounterValue(
+      GetCounterEvent event, Emitter<TwoGangState> emit) async {
    emit(LoadingInitialState());
    try {
      add(GetScheduleEvent());
@ -435,7 +464,8 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
        deviceId: twoGangId,
      );
      List<dynamic> jsonData = response;
-      listSchedule = jsonData.map((item) => ScheduleModel.fromJson(item)).toList();
+      listSchedule =
+          jsonData.map((item) => ScheduleModel.fromJson(item)).toList();
      emit(InitialState());
    } on DioException catch (e) {
      final errorData = e.response!.data;
@ -446,12 +476,13 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {

  int? getTimeStampWithoutSeconds(DateTime? dateTime) {
    if (dateTime == null) return null;
-    DateTime dateTimeWithoutSeconds =
-        DateTime(dateTime.year, dateTime.month, dateTime.day, dateTime.hour, dateTime.minute);
+    DateTime dateTimeWithoutSeconds = DateTime(dateTime.year, dateTime.month,
+        dateTime.day, dateTime.hour, dateTime.minute);
    return dateTimeWithoutSeconds.millisecondsSinceEpoch ~/ 1000;
  }

-  Future toggleRepeat(ToggleScheduleEvent event, Emitter<TwoGangState> emit) async {
+  Future toggleRepeat(
+      ToggleScheduleEvent event, Emitter<TwoGangState> emit) async {
    try {
      emit(LoadingInitialState());
      final response = await DevicesAPI.changeSchedule(
@ -470,7 +501,8 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
    }
  }

-  Future deleteSchedule(DeleteScheduleEvent event, Emitter<TwoGangState> emit) async {
+  Future deleteSchedule(
+      DeleteScheduleEvent event, Emitter<TwoGangState> emit) async {
    try {
      emit(LoadingInitialState());
      final response = await DevicesAPI.deleteSchedule(
@ -490,7 +522,8 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
    }
  }

-  void _fetchTwoGangWizardStatus(InitialWizardEvent event, Emitter<TwoGangState> emit) async {
+  void _fetchTwoGangWizardStatus(
+      InitialWizardEvent event, Emitter<TwoGangState> emit) async {
    emit(LoadingInitialState());
    try {
      devicesList = [];
@ -500,7 +533,8 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
          HomeCubit.getInstance().selectedSpace?.id ?? '', '2G');

      for (int i = 0; i < devicesList.length; i++) {
-        var response = await DevicesAPI.getDeviceStatus(devicesList[i].uuid ?? '');
+        var response =
+            await DevicesAPI.getDeviceStatus(devicesList[i].uuid ?? '');
        List<StatusModel> statusModelList = [];
        for (var status in response['status']) {
          statusModelList.add(StatusModel.fromJson(status));
@ -523,15 +557,16 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
          return true;
        });
      }
-      emit(UpdateGroupState(twoGangList: groupTwoGangList, allSwitches: allSwitchesOn));
+      emit(UpdateGroupState(
+          twoGangList: groupTwoGangList, allSwitches: allSwitchesOn));
    } catch (e) {
      emit(FailedState(error: e.toString()));
      return;
    }
  }

-  void _changeFirstWizardSwitch(
-      ChangeFirstWizardSwitchStatusEvent event, Emitter<TwoGangState> emit) async {
+  void _changeFirstWizardSwitch(ChangeFirstWizardSwitchStatusEvent event,
+      Emitter<TwoGangState> emit) async {
    emit(LoadingNewSate(twoGangModel: deviceStatus));
    try {
      bool allSwitchesValue = true;
@ -544,9 +579,11 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
        }
      });

-      emit(UpdateGroupState(twoGangList: groupTwoGangList, allSwitches: allSwitchesValue));
+      emit(UpdateGroupState(
+          twoGangList: groupTwoGangList, allSwitches: allSwitchesValue));

-      List<String> allDeviceIds = groupTwoGangList.map((device) => device.deviceId).toList();
+      List<String> allDeviceIds =
+          groupTwoGangList.map((device) => device.deviceId).toList();
      final response = await DevicesAPI.deviceBatchController(
        code: 'switch_1',
        devicesUuid: allDeviceIds,
@ -561,8 +598,8 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
    }
  }

-  void _changeSecondWizardSwitch(
-      ChangeSecondWizardSwitchStatusEvent event, Emitter<TwoGangState> emit) async {
+  void _changeSecondWizardSwitch(ChangeSecondWizardSwitchStatusEvent event,
+      Emitter<TwoGangState> emit) async {
    emit(LoadingNewSate(twoGangModel: deviceStatus));
    try {
      bool allSwitchesValue = true;
@ -574,9 +611,11 @@ class TwoGangBloc extends Bloc<TwoGangEvent, TwoGangState> {
          allSwitchesValue = false;
        }
      });
-      List<String> allDeviceIds = groupTwoGangList.map((device) => device.deviceId).toList();
+      List<String> allDeviceIds =
+          groupTwoGangList.map((device) => device.deviceId).toList();

-      emit(UpdateGroupState(twoGangList: groupTwoGangList, allSwitches: allSwitchesValue));
+      emit(UpdateGroupState(
+          twoGangList: groupTwoGangList, allSwitches: allSwitchesValue));

      final response = await DevicesAPI.deviceBatchController(
        code: 'switch_2',
--- a/lib/features/devices/bloc/two_touch_bloc/two_touch_bloc.dart
+++ b/lib/features/devices/bloc/two_touch_bloc/two_touch_bloc.dart
@ -99,41 +99,61 @@ class TwoTouchBloc extends Bloc<TwoTouchEvent, TwoTouchState> {
      }
      deviceStatus = TwoTouchModel.fromJson(statusModelList);
      emit(UpdateState(twoTouchModel: deviceStatus));
-      // _listenToChanges();
+      _listenToChanges();
    } catch (e) {
      emit(FailedState(error: e.toString()));
      return;
    }
  }

-  _listenToChanges() {
+  StreamSubscription<DatabaseEvent>? _streamSubscription;
+
+  void _listenToChanges() {
    try {
+      _streamSubscription?.cancel();
      DatabaseReference ref =
          FirebaseDatabase.instance.ref('device-status/$twoTouchId');
      Stream<DatabaseEvent> stream = ref.onValue;

-      stream.listen((DatabaseEvent event) async {
+      _streamSubscription = stream.listen((DatabaseEvent event) async {
        if (_timer != null) {
-          await Future.delayed(const Duration(seconds: 2));
+          await Future.delayed(const Duration(seconds: 1));
        }
-        Map<dynamic, dynamic> usersMap =
-            event.snapshot.value as Map<dynamic, dynamic>;
-        List<StatusModel> statusList = [];
+        if (event.snapshot.value != null) {
+          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']));
-        });
+          usersMap['status'].forEach((element) {
+            statusList.add(
+                StatusModel(code: element['code'], value: element['value']));
+          });
+          var switch1Status = statusList.firstWhere(
+              (status) => status.code == "switch_1",
+              orElse: () => StatusModel(code: "switch_1", value: false));
+
+          var switch2Status = statusList.firstWhere(
+              (status) => status.code == "switch_2",
+              orElse: () => StatusModel(code: "switch_2", value: false));
+          deviceStatus.firstSwitch = switch1Status.value as bool;
+          deviceStatus.secondSwitch = switch2Status.value as bool;

-        deviceStatus = TwoTouchModel.fromJson(statusList);
-        if (!isClosed) {
          add(TwoTouchUpdated());
        }
      });
-    } catch (_) {}
+    } catch (_) {
+    }
+  }
+
+  @override
+  Future<void> close() async {
+    _streamSubscription?.cancel();
+    _streamSubscription = null;
+    return super.close();
  }

  _twoTouchUpdated(TwoTouchUpdated event, Emitter<TwoTouchState> emit) {
+    emit(LoadingInitialState());
    emit(UpdateState(twoTouchModel: deviceStatus));
  }

--- a/lib/features/devices/bloc/wall_sensor_bloc/wall_sensor_bloc.dart
+++ b/lib/features/devices/bloc/wall_sensor_bloc/wall_sensor_bloc.dart
@ -1,3 +1,5 @@
+import 'dart:async';
+
 import 'package:firebase_database/firebase_database.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:syncrow_app/features/devices/bloc/wall_sensor_bloc/wall_sensor_state.dart';
@ -21,7 +23,8 @@ class WallSensorBloc extends Bloc<WallSensorEvent, WallSensorState> {
    on<GetDeviceReportsEvent>(_getDeviceReports);
  }

-  void _fetchCeilingSensorStatus(InitialEvent event, Emitter<WallSensorState> emit) async {
+  void _fetchCeilingSensorStatus(
+      InitialEvent event, Emitter<WallSensorState> emit) async {
    emit(LoadingInitialState());
    try {
      var response = await DevicesAPI.getDeviceStatus(deviceId);
@ -31,41 +34,62 @@ class WallSensorBloc extends Bloc<WallSensorEvent, WallSensorState> {
      }
      deviceStatus = WallSensorModel.fromJson(statusModelList);
      emit(UpdateState(wallSensorModel: deviceStatus));
-      // _listenToChanges();
+      _listenToChanges();
    } catch (e) {
      emit(FailedState(error: e.toString()));
      return;
    }
  }

-  _listenToChanges() {
+  Timer? _timer;
+  StreamSubscription<DatabaseEvent>? _streamSubscription;
+
+  void _listenToChanges() {
    try {
-      DatabaseReference ref = FirebaseDatabase.instance.ref('device-status/$deviceId');
+      _streamSubscription?.cancel();
+      DatabaseReference ref =
+          FirebaseDatabase.instance.ref('device-status/$deviceId');
      Stream<DatabaseEvent> stream = ref.onValue;

-      stream.listen((DatabaseEvent event) {
-        Map<dynamic, dynamic> usersMap = event.snapshot.value as Map<dynamic, dynamic>;
+      _streamSubscription = stream.listen((DatabaseEvent event) async {
+        if (_timer != null) {
+          await Future.delayed(const Duration(seconds: 2));
+        }
+        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']));
+          statusList
+              .add(StatusModel(code: element['code'], value: element['value']));
        });
-
        deviceStatus = WallSensorModel.fromJson(statusList);
-        add(WallSensorUpdatedEvent());
+        if (!isClosed) {
+          add(WallSensorUpdatedEvent());
+        }
      });
    } catch (_) {}
  }

-  _wallSensorUpdated(WallSensorUpdatedEvent event, Emitter<WallSensorState> emit) {
+  @override
+  Future<void> close() async {
+    _streamSubscription?.cancel();
+    _streamSubscription = null;
+    return super.close();
+  }
+
+  _wallSensorUpdated(
+      WallSensorUpdatedEvent event, Emitter<WallSensorState> emit) {
    emit(UpdateState(wallSensorModel: deviceStatus));
  }

-  void _changeIndicator(ChangeIndicatorEvent event, Emitter<WallSensorState> emit) async {
+  void _changeIndicator(
+      ChangeIndicatorEvent event, Emitter<WallSensorState> emit) async {
    emit(LoadingNewSate(wallSensorModel: deviceStatus));
    try {
      final response = await DevicesAPI.controlDevice(
-          DeviceControlModel(deviceId: deviceId, code: 'indicator', value: !event.value), deviceId);
+          DeviceControlModel(
+              deviceId: deviceId, code: 'indicator', value: !event.value),
+          deviceId);

      if (response['success'] ?? false) {
        deviceStatus.indicator = !event.value;
@ -74,11 +98,14 @@ class WallSensorBloc extends Bloc<WallSensorEvent, WallSensorState> {
    emit(UpdateState(wallSensorModel: deviceStatus));
  }

-  void _changeValue(ChangeValueEvent event, Emitter<WallSensorState> emit) async {
+  void _changeValue(
+      ChangeValueEvent event, Emitter<WallSensorState> emit) async {
    emit(LoadingNewSate(wallSensorModel: deviceStatus));
    try {
      final response = await DevicesAPI.controlDevice(
-          DeviceControlModel(deviceId: deviceId, code: event.code, value: event.value), deviceId);
+          DeviceControlModel(
+              deviceId: deviceId, code: event.code, value: event.value),
+          deviceId);

      if (response['success'] ?? false) {
        if (event.code == 'far_detection') {
@ -93,7 +120,8 @@ class WallSensorBloc extends Bloc<WallSensorEvent, WallSensorState> {
    emit(UpdateState(wallSensorModel: deviceStatus));
  }

-  void _getDeviceReports(GetDeviceReportsEvent event, Emitter<WallSensorState> emit) async {
+  void _getDeviceReports(
+      GetDeviceReportsEvent event, Emitter<WallSensorState> emit) async {
    emit(LoadingInitialState());

    try {
--- a/lib/features/devices/bloc/water_heater_bloc/water_heater_bloc.dart
+++ b/lib/features/devices/bloc/water_heater_bloc/water_heater_bloc.dart
@ -35,7 +35,8 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {
  List<ScheduleModel> listSchedule = [];
  DateTime? selectedTime = DateTime.now();

-  WaterHeaterBloc({required this.whId, required this.switchCode}) : super(WHInitialState()) {
+  WaterHeaterBloc({required this.whId, required this.switchCode})
+      : super(WHInitialState()) {
    on<WaterHeaterInitial>(_fetchWaterHeaterStatus);
    on<WaterHeaterSwitch>(_changeFirstSwitch);
    on<SetCounterValue>(_setCounterValue);
@ -60,7 +61,8 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {
    on<WaterHeaterUpdated>(_waterHeaterUpdated);
  }

-  void _fetchWaterHeaterStatus(WaterHeaterInitial event, Emitter<WaterHeaterState> emit) async {
+  void _fetchWaterHeaterStatus(
+      WaterHeaterInitial event, Emitter<WaterHeaterState> emit) async {
    emit(WHLoadingState());
    try {
      var response = await DevicesAPI.getDeviceStatus(whId);
@ -72,29 +74,33 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {
        statusModelList,
      );
      emit(UpdateState(whModel: deviceStatus));
-      // _listenToChanges();
+      _listenToChanges();
    } catch (e) {
      emit(WHFailedState(errorMessage: e.toString()));
      return;
    }
  }

-  _listenToChanges() {
+  //real-time db
+  StreamSubscription<DatabaseEvent>? _streamSubscription;
+  void _listenToChanges() {
    try {
-      DatabaseReference ref = FirebaseDatabase.instance.ref('device-status/$whId');
+      _streamSubscription?.cancel();
+      DatabaseReference ref =
+          FirebaseDatabase.instance.ref('device-status/$whId');
      Stream<DatabaseEvent> stream = ref.onValue;

-      stream.listen((DatabaseEvent event) async {
+      _streamSubscription = stream.listen((DatabaseEvent event) async {
        if (_timer != null) {
          await Future.delayed(const Duration(seconds: 2));
        }
-        Map<dynamic, dynamic> usersMap = event.snapshot.value as Map<dynamic, dynamic>;
+        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']));
+          statusList
+              .add(StatusModel(code: element['code'], value: element['value']));
        });
-
        deviceStatus = WHModel.fromJson(statusList);
        if (!isClosed) {
          add(WaterHeaterUpdated());
@ -103,12 +109,21 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {
    } catch (_) {}
  }

-  _waterHeaterUpdated(WaterHeaterUpdated event, Emitter<WaterHeaterState> emit) async {
+  @override
+  Future<void> close() async {
+    _streamSubscription?.cancel();
+    _streamSubscription = null;
+    return super.close();
+  }
+
+  _waterHeaterUpdated(
+      WaterHeaterUpdated event, Emitter<WaterHeaterState> emit) async {
    emit(WHLoadingState());
    emit(UpdateState(whModel: deviceStatus));
  }

-  void _changeFirstSwitch(WaterHeaterSwitch event, Emitter<WaterHeaterState> emit) async {
+  void _changeFirstSwitch(
+      WaterHeaterSwitch event, Emitter<WaterHeaterState> emit) async {
    emit(LoadingNewSate(whModel: deviceStatus));
    try {
      deviceStatus.firstSwitch = !event.whSwitch;
@ -118,7 +133,10 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {
      }
      _timer = Timer(const Duration(milliseconds: 500), () async {
        final response = await DevicesAPI.controlDevice(
-            DeviceControlModel(deviceId: whId, code: 'switch_1', value: deviceStatus.firstSwitch),
+            DeviceControlModel(
+                deviceId: whId,
+                code: 'switch_1',
+                value: deviceStatus.firstSwitch),
            whId);

        if (!response['success']) {
@ -132,13 +150,16 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {

  //=====================---------- timer ----------------------------------------

-  void _setCounterValue(SetCounterValue event, Emitter<WaterHeaterState> emit) async {
+  void _setCounterValue(
+      SetCounterValue event, Emitter<WaterHeaterState> emit) async {
    emit(LoadingNewSate(whModel: deviceStatus));
    int seconds = 0;
    try {
      seconds = event.duration.inSeconds;
      final response = await DevicesAPI.controlDevice(
-          DeviceControlModel(deviceId: whId, code: event.deviceCode, value: seconds), whId);
+          DeviceControlModel(
+              deviceId: whId, code: event.deviceCode, value: seconds),
+          whId);

      if (response['success'] ?? false) {
        if (event.deviceCode == 'countdown_1') {
@ -160,7 +181,8 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {
    }
  }

-  void _getCounterValue(GetCounterEvent event, Emitter<WaterHeaterState> emit) async {
+  void _getCounterValue(
+      GetCounterEvent event, Emitter<WaterHeaterState> emit) async {
    emit(WHLoadingState());
    try {
      var response = await DevicesAPI.getDeviceStatus(whId);
@ -250,7 +272,8 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {
        deviceId: whId,
      );
      List<dynamic> jsonData = response;
-      listSchedule = jsonData.map((item) => ScheduleModel.fromJson(item)).toList();
+      listSchedule =
+          jsonData.map((item) => ScheduleModel.fromJson(item)).toList();
      emit(WHInitialState());
    } on DioException catch (e) {
      final errorData = e.response!.data;
@ -261,12 +284,13 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {

  int? getTimeStampWithoutSeconds(DateTime? dateTime) {
    if (dateTime == null) return null;
-    DateTime dateTimeWithoutSeconds =
-        DateTime(dateTime.year, dateTime.month, dateTime.day, dateTime.hour, dateTime.minute);
+    DateTime dateTimeWithoutSeconds = DateTime(dateTime.year, dateTime.month,
+        dateTime.day, dateTime.hour, dateTime.minute);
    return dateTimeWithoutSeconds.millisecondsSinceEpoch ~/ 1000;
  }

-  Future toggleChange(ToggleScheduleEvent event, Emitter<WaterHeaterState> emit) async {
+  Future toggleChange(
+      ToggleScheduleEvent event, Emitter<WaterHeaterState> emit) async {
    try {
      emit(WHLoadingState());
      final response = await DevicesAPI.changeSchedule(
@ -284,7 +308,8 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {
    }
  }

-  Future deleteSchedule(DeleteScheduleEvent event, Emitter<WaterHeaterState> emit) async {
+  Future deleteSchedule(
+      DeleteScheduleEvent event, Emitter<WaterHeaterState> emit) async {
    try {
      emit(WHLoadingState());
      final response = await DevicesAPI.deleteSchedule(
@ -303,7 +328,8 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {
    }
  }

-  void _toggleCreateCirculate(ToggleCreateCirculate event, Emitter<WaterHeaterState> emit) {
+  void _toggleCreateCirculate(
+      ToggleCreateCirculate event, Emitter<WaterHeaterState> emit) {
    emit(WHLoadingState());
    createCirculate = !createCirculate;
    selectedDays.clear();
@ -311,13 +337,15 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {
    emit(UpdateCreateScheduleState(createCirculate));
  }

-  void toggleSelectedIndex(ToggleSelectedEvent event, Emitter<WaterHeaterState> emit) {
+  void toggleSelectedIndex(
+      ToggleSelectedEvent event, Emitter<WaterHeaterState> emit) {
    emit(WHLoadingState());
    selectedTabIndex = event.index;
    emit(ChangeSlidingSegmentState(value: selectedTabIndex));
  }

-  void toggleCreateSchedule(ToggleCreateScheduleEvent event, Emitter<WaterHeaterState> emit) {
+  void toggleCreateSchedule(
+      ToggleCreateScheduleEvent event, Emitter<WaterHeaterState> emit) {
    emit(WHLoadingState());
    createSchedule = !createSchedule;
    selectedDays.clear();
@ -366,8 +394,8 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {
  List<GroupWHModel> groupWaterHeaterList = [];
  bool allSwitchesOn = true;

-  void _changeFirstWizardSwitch(
-      ChangeFirstWizardSwitchStatusEvent event, Emitter<WaterHeaterState> emit) async {
+  void _changeFirstWizardSwitch(ChangeFirstWizardSwitchStatusEvent event,
+      Emitter<WaterHeaterState> emit) async {
    emit(LoadingNewSate(whModel: deviceStatus));
    try {
      bool allSwitchesValue = true;
@ -379,7 +407,8 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {
          allSwitchesValue = false;
        }
      });
-      emit(UpdateGroupState(twoGangList: groupWaterHeaterList, allSwitches: allSwitchesValue));
+      emit(UpdateGroupState(
+          twoGangList: groupWaterHeaterList, allSwitches: allSwitchesValue));

      final response = await DevicesAPI.deviceBatchController(
        code: 'switch_1',
@ -394,7 +423,8 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {
    }
  }

-  void _fetchWHWizardStatus(InitialWizardEvent event, Emitter<WaterHeaterState> emit) async {
+  void _fetchWHWizardStatus(
+      InitialWizardEvent event, Emitter<WaterHeaterState> emit) async {
    emit(WHLoadingState());
    try {
      devicesList = [];
@ -404,7 +434,8 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {
          HomeCubit.getInstance().selectedSpace?.id ?? '', 'WH');

      for (int i = 0; i < devicesList.length; i++) {
-        var response = await DevicesAPI.getDeviceStatus(devicesList[i].uuid ?? '');
+        var response =
+            await DevicesAPI.getDeviceStatus(devicesList[i].uuid ?? '');
        List<StatusModel> statusModelList = [];
        for (var status in response['status']) {
          statusModelList.add(StatusModel.fromJson(status));
@ -426,23 +457,27 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {
          return true;
        });
      }
-      emit(UpdateGroupState(twoGangList: groupWaterHeaterList, allSwitches: allSwitchesOn));
+      emit(UpdateGroupState(
+          twoGangList: groupWaterHeaterList, allSwitches: allSwitchesOn));
    } catch (e) {
      // emit(FailedState(error: e.toString()));
      return;
    }
  }

-  void _groupAllOn(GroupAllOnEvent event, Emitter<WaterHeaterState> emit) async {
+  void _groupAllOn(
+      GroupAllOnEvent event, Emitter<WaterHeaterState> emit) async {
    emit(LoadingNewSate(whModel: deviceStatus));
    try {
      for (int i = 0; i < groupWaterHeaterList.length; i++) {
        groupWaterHeaterList[i].firstSwitch = true;
      }

-      emit(UpdateGroupState(twoGangList: groupWaterHeaterList, allSwitches: true));
+      emit(UpdateGroupState(
+          twoGangList: groupWaterHeaterList, allSwitches: true));

-      List<String> allDeviceIds = groupWaterHeaterList.map((device) => device.deviceId).toList();
+      List<String> allDeviceIds =
+          groupWaterHeaterList.map((device) => device.deviceId).toList();

      final response = await DevicesAPI.deviceBatchController(
        code: 'switch_1',
@ -460,15 +495,18 @@ class WaterHeaterBloc extends Bloc<WaterHeaterEvent, WaterHeaterState> {
    }
  }

-  void _groupAllOff(GroupAllOffEvent event, Emitter<WaterHeaterState> emit) async {
+  void _groupAllOff(
+      GroupAllOffEvent event, Emitter<WaterHeaterState> emit) async {
    emit(LoadingNewSate(whModel: deviceStatus));
    try {
      for (int i = 0; i < groupWaterHeaterList.length; i++) {
        groupWaterHeaterList[i].firstSwitch = false;
      }
-      emit(UpdateGroupState(twoGangList: groupWaterHeaterList, allSwitches: false));
+      emit(UpdateGroupState(
+          twoGangList: groupWaterHeaterList, allSwitches: false));

-      List<String> allDeviceIds = groupWaterHeaterList.map((device) => device.deviceId).toList();
+      List<String> allDeviceIds =
+          groupWaterHeaterList.map((device) => device.deviceId).toList();

      final response = await DevicesAPI.deviceBatchController(
        code: 'switch_1',
--- a/lib/features/devices/bloc/water_leak_bloc/water_leak_bloc.dart
+++ b/lib/features/devices/bloc/water_leak_bloc/water_leak_bloc.dart
@ -1,6 +1,5 @@
 import 'dart:async';
 import 'package:dio/dio.dart';
-import 'package:firebase_database/firebase_database.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:syncrow_app/features/devices/bloc/water_leak_bloc/water_leak_event.dart';
 import 'package:syncrow_app/features/devices/bloc/water_leak_bloc/water_leak_state.dart';
@ -21,7 +20,6 @@ class WaterLeakBloc extends Bloc<WaterLeakEvent, WaterLeakState> {
    on<ToggleClosingReminderEvent>(_toggleClosingReminder);
    on<ToggleWaterLeakAlarmEvent>(_toggleWaterLeakAlarm);
  }
-  Timer? _timer;
  bool lowBattery = false;
  bool closingReminder = false;
  bool waterAlarm = false;
@ -134,32 +132,42 @@ class WaterLeakBloc extends Bloc<WaterLeakEvent, WaterLeakState> {
      emit(WaterLeakFailedState(errorMessage: errorMessage));
    }
  }
+  //  Timer? _timer;
+  // StreamSubscription<DatabaseEvent>? _streamSubscription;
+  // void _listenToChanges() {
+  //   try {
+  //     _streamSubscription?.cancel();
+  //     DatabaseReference ref =
+  //         FirebaseDatabase.instance.ref('device-status/$WLId');
+  //     Stream<DatabaseEvent> stream = ref.onValue;

-  _listenToChanges() {
-    try {
-      DatabaseReference ref =
-          FirebaseDatabase.instance.ref('device-status/$WLId');
-      Stream<DatabaseEvent> stream = ref.onValue;
+  //     _streamSubscription = stream.listen((DatabaseEvent event) async {
+  //       if (_timer != null) {
+  //         await Future.delayed(const Duration(seconds: 2));
+  //       }
+  //       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 = WaterLeakModel.fromJson(statusList);
+  //       if (!isClosed) {
+  //         add(
+  //           WaterLeakSwitch(switchD: deviceStatus.waterContactState),
+  //         );
+  //       }
+  //     });
+  //   } catch (_) {}
+  // }

-      stream.listen((DatabaseEvent event) async {
-        if (_timer != null) {
-          await Future.delayed(const Duration(seconds: 2));
-        }
-        Map<dynamic, dynamic> usersMap =
-            event.snapshot.value as Map<dynamic, dynamic>;
-        List<StatusModel> statusList = [];
+  // @override
+  // Future<void> close() async {
+  //   _streamSubscription?.cancel();
+  //   _streamSubscription = null;
+  //   return super.close();
+  // }

-        usersMap['status'].forEach((element) {
-          statusList.add(StatusModel(code: element['code'], value: true));
-        });

-        deviceStatus = WaterLeakModel.fromJson(statusList);
-        if (!isClosed) {
-          add(
-            WaterLeakSwitch(switchD: deviceStatus.waterContactState),
-          );
-        }
-      });
-    } catch (_) {}
-  }
 }
--- a/lib/features/devices/view/widgets/ACs/acs_view.dart
+++ b/lib/features/devices/view/widgets/ACs/acs_view.dart
@ -23,6 +23,7 @@ class ACsView extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return BlocProvider(
+      
      create: (context) => ACsBloc(acId: deviceModel?.uuid ?? '')
        ..add(AcsInitial(allAcs: deviceModel != null ? false : true)),
      child: BlocBuilder<ACsBloc, AcsState>(
--- a/lib/features/devices/view/widgets/garage_door/garage_door_screen.dart
+++ b/lib/features/devices/view/widgets/garage_door/garage_door_screen.dart
--- a/lib/features/devices/view/widgets/one_gang/one_gang_screen.dart
+++ b/lib/features/devices/view/widgets/one_gang/one_gang_screen.dart
@ -20,8 +20,9 @@ class OneGangScreen extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return BlocProvider(
-      create: (context) => OneGangBloc(switchCode: 'switch_1', oneGangId: device?.uuid ?? '')
-        ..add(const InitialEvent(groupScreen: false)),
+      create: (context) =>
+          OneGangBloc(switchCode: 'switch_1', oneGangId: device?.uuid ?? '')
+            ..add(const InitialEvent(groupScreen: false)),
      child: BlocBuilder<OneGangBloc, OneGangState>(
        builder: (context, state) {
          OneGangModel oneGangModel = OneGangModel(
@ -36,13 +37,15 @@ class OneGangScreen extends StatelessWidget {
          }
          return state is LoadingInitialState
              ? const Center(
-                  child:
-                      DefaultContainer(width: 50, height: 50, child: CircularProgressIndicator()),
+                  child: DefaultContainer(
+                      width: 50,
+                      height: 50,
+                      child: CircularProgressIndicator()),
                )
              : RefreshIndicator(
                  onRefresh: () async {
-                    BlocProvider.of<OneGangBloc>(context)
-                        .add(InitialEvent(groupScreen: device != null ? false : true));
+                    BlocProvider.of<OneGangBloc>(context).add(InitialEvent(
+                        groupScreen: device != null ? false : true));
                  },
                  child: ListView(
                    children: [
@ -55,7 +58,8 @@ class OneGangScreen extends StatelessWidget {
                            const Expanded(child: SizedBox.shrink()),
                            Expanded(
                              child: Row(
-                                mainAxisAlignment: MainAxisAlignment.spaceAround,
+                                mainAxisAlignment:
+                                    MainAxisAlignment.spaceAround,
                                crossAxisAlignment: CrossAxisAlignment.center,
                                children: [
                                  Column(
@ -64,9 +68,10 @@ class OneGangScreen extends StatelessWidget {
                                        threeGangSwitch: device!,
                                        value: oneGangModel.firstSwitch,
                                        action: () {
-                                          BlocProvider.of<OneGangBloc>(context).add(
-                                              ChangeFirstSwitchStatusEvent(
-                                                  value: oneGangModel.firstSwitch));
+                                          BlocProvider.of<OneGangBloc>(context)
+                                              .add(ChangeFirstSwitchStatusEvent(
+                                                  value: oneGangModel
+                                                      .firstSwitch));
                                        },
                                      ),
                                      const SizedBox(height: 20),
@ -74,7 +79,8 @@ class OneGangScreen extends StatelessWidget {
                                        width: 70,
                                        child: BodySmall(
                                          text: " Entrance Light",
-                                          fontColor: ColorsManager.textPrimaryColor,
+                                          fontColor:
+                                              ColorsManager.textPrimaryColor,
                                          textAlign: TextAlign.center,
                                        ),
                                      ),
@ -94,20 +100,24 @@ class OneGangScreen extends StatelessWidget {
                                      Card(
                                        elevation: 3,
                                        shape: RoundedRectangleBorder(
-                                          borderRadius: BorderRadius.circular(100),
+                                          borderRadius:
+                                              BorderRadius.circular(100),
                                        ),
                                        child: GestureDetector(
                                          onTap: () {
                                            Navigator.push(
                                                context,
                                                PageRouteBuilder(
-                                                    pageBuilder:
-                                                        (context, animation1, animation2) =>
-                                                            TimerScheduleScreen(
-                                                              switchCode: 'switch_1',
-                                                              device: device!,
-                                                              deviceCode: 'countdown_1',
-                                                            )));
+                                                    pageBuilder: (context,
+                                                            animation1,
+                                                            animation2) =>
+                                                        TimerScheduleScreen(
+                                                          switchCode:
+                                                              'switch_1',
+                                                          device: device!,
+                                                          deviceCode:
+                                                              'countdown_1',
+                                                        )));
                                          },
                                          child: Stack(
                                            alignment: Alignment.center,
@ -117,7 +127,9 @@ class OneGangScreen extends StatelessWidget {
                                                height: 60,
                                                decoration: BoxDecoration(
                                                  color: Colors.grey[300],
-                                                  borderRadius: BorderRadius.circular(100),
+                                                  borderRadius:
+                                                      BorderRadius.circular(
+                                                          100),
                                                ),
                                              ),
                                              Container(
@ -125,12 +137,15 @@ class OneGangScreen extends StatelessWidget {
                                                height: 40,
                                                decoration: BoxDecoration(
                                                  color: Colors.white,
-                                                  borderRadius: BorderRadius.circular(100),
+                                                  borderRadius:
+                                                      BorderRadius.circular(
+                                                          100),
                                                ),
                                                child: Center(
                                                  child: Icon(
                                                    Icons.access_time,
-                                                    color: ColorsManager.primaryColorWithOpacity,
+                                                    color: ColorsManager
+                                                        .primaryColorWithOpacity,
                                                    size: 25,
                                                  ),
                                                ),
--- a/lib/features/devices/view/widgets/room_page_switch.dart
+++ b/lib/features/devices/view/widgets/room_page_switch.dart
@ -119,6 +119,8 @@ Future<void> showDeviceInterface(
    required BuildContext context,
    required isAllDevices,
    List<DeviceModel>? allDevices}) async {
+  print('object-----${device.uuid} ${device.name}');
+
  final devicesCubit = context.read<DevicesCubit>();

  switch (device.productType) {
Author	SHA1	Message	Date
mohammad	d95588ce84	remove unused code	2025-03-03 17:34:15 +03:00
mohammad	7e2e591d71	remove unused code	2025-03-01 15:19:15 +03:00
mohammad	2ec81bda9c	connect the real time for all devices	2025-03-01 15:08:51 +03:00
mohammadnemer1	3b0f51473c	Merge pull request #73 from SyncrowIOT/SP-1190 Sp 1190	2025-02-26 12:20:06 +03:00
mohammad	13757d89ee	Merged with dev	2025-02-26 12:17:57 +03:00
mohammad	d3068b8e14	changes in threeGang	2025-02-26 10:58:32 +03:00
mohammad	7c5d7e1dda	remove unused code	2025-02-25 12:45:23 +03:00
mohammad	0a97a4867d	disconnect real-time to some devices	2025-02-25 12:41:49 +03:00
Abdullah	6e55b488aa	Merge pull request #72 from SyncrowIOT/feat/change-hardcode-projectid updated project hardcoded values	2025-02-24 12:06:06 +03:00
mohammad	2dc4e16a75	connect all devices to real-time and change the channel function	2025-02-16 14:54:39 +03:00
mohammad	cd41720244	active the implemented device	2025-02-16 10:04:34 +03:00