door sensor

lib/features/devices/bloc/door_sensor_bloc/door_sensor_bloc.dart

@@ -0,0 +1,220 @@
+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/door_sensor_bloc/door_sensor_event.dart';
+import 'package:syncrow_app/features/devices/bloc/door_sensor_bloc/door_sensor_state.dart';
+import 'package:syncrow_app/features/devices/model/device_control_model.dart';
+import 'package:syncrow_app/features/devices/model/door_sensor_model.dart';
+import 'package:syncrow_app/features/devices/model/report_model.dart';
+import 'package:syncrow_app/features/devices/model/status_model.dart';
+import 'package:syncrow_app/services/api/devices_api.dart';
+
+class DoorSensorBloc extends Bloc<DoorSensorEvent, DoorSensorState> {
+  final String DSId;
+  final String switchCode;
+  DoorSensorBloc({required this.DSId, required this.switchCode})
+      : super(const DoorSensorState()) {
+    on<DoorSensorInitial>(_fetchWaterHeaterStatus);
+    on<ReportLogsInitial>(fetchLogsForLastMonth);
+    on<DoorSensorSwitch>(_changeFirstSwitch);
+    on<ToggleLowBatteryEvent>(_toggleLowBattery);
+    on<ToggleClosingReminderEvent>(_toggleClosingReminder);
+    on<ToggleDoorAlarmEvent>(_toggleDoorAlarm);
+  }
+  Timer? _timer;
+  bool lowBattery = false;
+  bool closingReminder = false;
+  bool doorAlarm = false;
+  DoorSensorModel deviceStatus =
+      DoorSensorModel(doorContactState: false, batteryPercentage: 0);
+  void _fetchWaterHeaterStatus(
+      DoorSensorInitial event, Emitter<DoorSensorState> emit) async {
+    emit(DoorSensorLoadingState());
+    try {
+      var response = await DevicesAPI.getDeviceStatus(DSId);
+      List<StatusModel> statusModelList = [];
+      for (var status in response['status']) {
+        statusModelList.add(StatusModel.fromJson(status));
+      }
+      deviceStatus = DoorSensorModel.fromJson(
+        statusModelList,
+      );
+      emit(UpdateState(doorSensor: deviceStatus));
+      Future.delayed(const Duration(milliseconds: 500));
+      // _listenToChanges();
+    } catch (e) {
+      emit(DoorSensorFailedState(errorMessage: e.toString()));
+      return;
+    }
+  }
+
+  void _changeFirstSwitch(
+      DoorSensorSwitch event, Emitter<DoorSensorState> emit) async {
+    emit(LoadingNewSate(doorSensor: deviceStatus));
+    try {
+      deviceStatus.doorContactState = !event.switchD;
+      emit(UpdateState(doorSensor: deviceStatus));
+      final response = await DevicesAPI.controlDevice(
+          DeviceControlModel(
+              deviceId: DSId,
+              code: 'doorcontact_state',
+              value: deviceStatus.doorContactState),
+          DSId);
+
+      if (!response['success']) {
+        // add(InitialEvent(groupScreen: oneGangGroup));
+      }
+    } catch (_) {
+      emit(DoorSensorFailedState(errorMessage: _.toString()));
+    }
+  }
+
+  // Toggle functions for each switch
+  void _toggleLowBattery(
+      ToggleLowBatteryEvent event, Emitter<DoorSensorState> emit) async {
+    emit(LoadingNewSate(doorSensor: deviceStatus));
+    try {
+      lowBattery = event.isLowBatteryEnabled;
+      emit(UpdateState(doorSensor: deviceStatus));
+
+      // API call to update the state, if necessary
+      await DevicesAPI.controlDevice(
+        DeviceControlModel(
+          deviceId: DSId,
+          code: 'low_battery',
+          value: lowBattery,
+        ),
+        DSId,
+      );
+    } catch (e) {
+      emit(DoorSensorFailedState(errorMessage: e.toString()));
+    }
+  }
+
+  void _toggleClosingReminder(
+      ToggleClosingReminderEvent event, Emitter<DoorSensorState> emit) async {
+    emit(LoadingNewSate(doorSensor: deviceStatus));
+    try {
+      closingReminder = event.isClosingReminderEnabled;
+      emit(UpdateState(doorSensor: deviceStatus));
+
+      // API call to update the state, if necessary
+      await DevicesAPI.controlDevice(
+        DeviceControlModel(
+          deviceId: DSId,
+          code: 'closing_reminder',
+          value: closingReminder,
+        ),
+        DSId,
+      );
+    } catch (e) {
+      emit(DoorSensorFailedState(errorMessage: e.toString()));
+    }
+  }
+
+  void _toggleDoorAlarm(
+      ToggleDoorAlarmEvent event, Emitter<DoorSensorState> emit) async {
+    emit(LoadingNewSate(doorSensor: deviceStatus));
+    try {
+      doorAlarm = event.isDoorAlarmEnabled;
+      emit(UpdateState(doorSensor: deviceStatus));
+
+      // API call to update the state, if necessary
+      await DevicesAPI.controlDevice(
+        DeviceControlModel(
+          deviceId: DSId,
+          code: 'door_alarm',
+          value: doorAlarm,
+        ),
+        DSId,
+      );
+    } catch (e) {
+      emit(DoorSensorFailedState(errorMessage: e.toString()));
+    }
+  }
+
+  final List<RecordGroup> recordGroups = [
+    RecordGroup(
+      date: DateTime(2024, 8, 31),
+      records: [
+        Record(status: 'Opened', time: '15:10:25', isOpen: false),
+        Record(status: 'Closed', time: '12:24:45', isOpen: false),
+        Record(status: 'Opened', time: '12:20:05', isOpen: true),
+      ],
+    ),
+    RecordGroup(
+      date: DateTime(2024, 8, 30),
+      records: [
+        Record(status: 'Opened', time: '14:15:30', isOpen: true),
+        Record(status: 'Closed', time: '10:22:45', isOpen: false),
+      ],
+    ),
+    RecordGroup(
+      date: DateTime(2024, 8, 29),
+      records: [
+        Record(status: 'Opened', time: '13:45:00', isOpen: true),
+        Record(status: 'Closed', time: '11:30:15', isOpen: false),
+        Record(status: 'Opened', time: '09:20:10', isOpen: true),
+      ],
+    ),
+  ];
+
+  Future<void> fetchLogsForLastMonth(
+      ReportLogsInitial event, Emitter<DoorSensorState> emit) async {
+    // Get the current date and time
+    DateTime now = DateTime.now();
+
+    // Calculate the date one month ago
+    DateTime lastMonth = DateTime(now.year, now.month - 1, now.day);
+
+    // Convert the date to milliseconds since epoch (Unix timestamp in milliseconds)
+    int startTime = lastMonth.millisecondsSinceEpoch;
+    int endTime = now.millisecondsSinceEpoch;
+    try {
+      var response = await DevicesAPI.getReportLogs(
+        startTime:  startTime.toString(), // Convert to String if the API expects it
+        endTime: endTime.toString(), // Convert to String if the API expects it
+        deviceUuid: DSId,
+        code: 'doorcontact_state',
+      );
+      // Process response here
+      print(response);
+    } on DioException catch (e) {
+      final errorData = e.response!.data;
+      String errorMessage = errorData['message'];
+      // Handle error
+      print('Error fetching logs: ${errorMessage}');
+    }
+  }
+
+  _listenToChanges() {
+    try {
+      DatabaseReference ref =
+          FirebaseDatabase.instance.ref('device-status/$DSId');
+      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: element['value']));
+        });
+
+        deviceStatus = DoorSensorModel.fromJson(statusList);
+        if (!isClosed) {
+          add(
+            DoorSensorSwitch(switchD: deviceStatus.doorContactState),
+          );
+        }
+      });
+    } catch (_) {}
+  }
+}

lib/features/devices/bloc/door_sensor_bloc/door_sensor_event.dart

@@ -0,0 +1,102 @@
+import 'package:equatable/equatable.dart';
+
+abstract class DoorSensorEvent extends Equatable {
+  const DoorSensorEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+class DoorSensorLoading extends DoorSensorEvent {}
+
+class DoorSensorSwitch extends DoorSensorEvent {
+  final bool switchD;
+  final String deviceId;
+  final String productId;
+  const DoorSensorSwitch({required this.switchD, this.deviceId = '', this.productId = ''});
+
+  @override
+  List<Object> get props => [switchD, deviceId, productId];
+}
+
+class DoorSensorUpdated extends DoorSensorEvent {}
+
+class DoorSensorInitial extends DoorSensorEvent {
+  const DoorSensorInitial();
+}
+
+class ReportLogsInitial extends DoorSensorEvent {
+  const ReportLogsInitial();
+}
+
+
+class DoorSensorChangeStatus extends DoorSensorEvent {}
+
+
+class GetCounterEvent extends DoorSensorEvent {
+  final String deviceCode;
+  const GetCounterEvent({required this.deviceCode});
+  @override
+  List<Object> get props => [deviceCode];
+}
+
+
+
+class ToggleLowBatteryEvent extends DoorSensorEvent {
+  final bool isLowBatteryEnabled;
+
+  const ToggleLowBatteryEvent(this.isLowBatteryEnabled);
+
+  @override
+  List<Object> get props => [isLowBatteryEnabled];
+}
+
+class ToggleClosingReminderEvent extends DoorSensorEvent {
+  final bool isClosingReminderEnabled;
+
+  const ToggleClosingReminderEvent(this.isClosingReminderEnabled);
+
+  @override
+  List<Object> get props => [isClosingReminderEnabled];
+}
+
+class ToggleDoorAlarmEvent extends DoorSensorEvent {
+  final bool isDoorAlarmEnabled;
+
+  const ToggleDoorAlarmEvent(this.isDoorAlarmEnabled);
+
+  @override
+  List<Object> get props => [isDoorAlarmEnabled];
+}
+
+
+
+class SetCounterValue extends DoorSensorEvent {
+  final Duration duration;
+  final String deviceCode;
+  const SetCounterValue({required this.duration, required this.deviceCode});
+  @override
+  List<Object> get props => [duration, deviceCode];
+}
+
+class StartTimer extends DoorSensorEvent {
+  final int duration;
+
+  const StartTimer(this.duration);
+
+  @override
+  List<Object> get props => [duration];
+}
+
+class TickTimer extends DoorSensorEvent {
+  final int remainingTime;
+
+  const TickTimer(this.remainingTime);
+
+  @override
+  List<Object> get props => [remainingTime];
+}
+
+class StopTimer extends DoorSensorEvent {}
+
+class OnClose extends DoorSensorEvent {}

lib/features/devices/bloc/door_sensor_bloc/door_sensor_state.dart

@@ -0,0 +1,128 @@
+import 'package:equatable/equatable.dart';
+import 'package:syncrow_app/features/devices/model/door_sensor_model.dart';
+
+ class DoorSensorState  extends Equatable {
+  const DoorSensorState();
+
+  @override
+  List<Object> get props => [];
+}
+
+class DoorSensorInitialState extends DoorSensorState {}
+
+class  DoorSensorLoadingState extends DoorSensorState {}
+
+class DoorSensorFailedState extends DoorSensorState {
+  final String errorMessage;
+
+  const DoorSensorFailedState({required this.errorMessage});
+
+  @override
+  List<Object> get props => [errorMessage];
+}
+
+class UpdateState extends DoorSensorState {
+  final DoorSensorModel doorSensor;
+  const UpdateState({required this.doorSensor});
+
+  @override
+  List<Object> get props => [doorSensor];
+}
+
+
+class LoadingNewSate extends DoorSensorState {
+  final DoorSensorModel doorSensor;
+  const LoadingNewSate({required this.doorSensor});
+
+  @override
+  List<Object> get props => [doorSensor];
+}
+
+// class WHModifyingState extends DoorSensorState {
+//   final WHModel whStatusModel;
+//   const WHModifyingState({required this.whStatusModel});
+//
+//   @override
+//   List<Object> get props => [whStatusModel];
+// }
+//
+// class GetWHStatusState extends DoorSensorState {
+//   final WHModel whStatusModel;
+//   const GetWHStatusState({required this.whStatusModel});
+//
+//   @override
+//   List<Object> get props => [whStatusModel];
+// }
+//
+//
+// class WHFailedState extends WaterHeaterState {
+//   final String errorMessage;
+//
+//   const WHFailedState({required this.errorMessage});
+//
+//   @override
+//   List<Object> get props => [errorMessage];
+// }
+
+
+// class LoadingNewSate extends WaterHeaterState {
+//   final WHModel whModel;
+//   const LoadingNewSate({required this.whModel});
+//
+//   @override
+//   List<Object> get props => [whModel];
+// }
+// class TimerRunComplete extends WaterHeaterState {}
+// class UpdateTimerState extends WaterHeaterState {
+//   final int seconds;
+//   const UpdateTimerState({required this.seconds});
+//
+//   @override
+//   List<Object> get props => [seconds];
+// }
+//
+// class TimerRunInProgress extends WaterHeaterState {
+//   final int remainingTime;
+//
+//   const TimerRunInProgress(this.remainingTime);
+//
+//   @override
+//   List<Object> get props => [remainingTime];
+// }
+//
+// class SaveSchedule extends WaterHeaterState {}
+// class ChangeTimeState extends WaterHeaterState {}
+// class UpdateCreateScheduleState extends WaterHeaterState {
+//   final bool createSchedule;
+//   UpdateCreateScheduleState(this.createSchedule);
+// }
+// class IsToggleState extends WaterHeaterState {
+//   final bool? onOff;
+//   const IsToggleState({this.onOff});
+// }
+//
+//
+// class UpdateState extends WaterHeaterState {
+//   final WHModel whModel;
+//   const UpdateState({required this.whModel});
+//
+//   @override
+//   List<Object> get props => [WHModel];
+// }
+//
+// class ChangeSwitchStatusEvent extends WaterHeaterState {
+//   final bool value;
+//   final String deviceId;
+//   const ChangeSwitchStatusEvent({required this.value, this.deviceId = ''});
+//   @override
+//   List<Object> get props => [value, deviceId];
+// }
+//
+// class ChangeSlidingSegmentState extends WaterHeaterState {
+//   final int value;
+//
+//   const ChangeSlidingSegmentState({required this.value});
+//
+//   @override
+//   List<Object> get props => [value];
+// }

lib/features/devices/model/door_sensor_model.dart

@@ -0,0 +1,33 @@
+
+
+
+
+import 'package:syncrow_app/features/devices/model/status_model.dart';
+
+class DoorSensorModel {
+  bool doorContactState;
+  int batteryPercentage;
+
+  DoorSensorModel(
+      {required this.doorContactState,
+        required this.batteryPercentage,
+      });
+
+  factory DoorSensorModel.fromJson(List<StatusModel> jsonList) {
+    late bool _doorContactState;
+    late int _batteryPercentage;
+
+
+    for (int i = 0; i < jsonList.length; i++) {
+      if (jsonList[i].code == 'doorcontact_state') {
+        _doorContactState = jsonList[i].value ?? false;
+      } else  if (jsonList[i].code == 'battery_percentage') {
+        _batteryPercentage = jsonList[i].value ?? 0;
+      }
+    }
+    return DoorSensorModel(
+      doorContactState: _doorContactState,
+      batteryPercentage: _batteryPercentage,
+    );
+  }
+}

lib/features/devices/model/report_model.dart

@@ -0,0 +1,23 @@
+// Record model
+class Record {
+  final String status;
+  final String time;
+  final bool isOpen;
+
+  Record({
+    required this.status,
+    required this.time,
+    required this.isOpen,
+  });
+}
+
+// RecordGroup model to group records by date
+class RecordGroup {
+  final DateTime date;
+  final List<Record> records;
+
+  RecordGroup({
+    required this.date,
+    required this.records,
+  });
+}

lib/features/devices/view/widgets/door_sensor/door_notification_settings.dart

@@ -0,0 +1,123 @@
+import 'package:flutter/cupertino.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:syncrow_app/features/devices/bloc/door_sensor_bloc/door_sensor_bloc.dart';
+import 'package:syncrow_app/features/devices/bloc/door_sensor_bloc/door_sensor_event.dart';
+import 'package:syncrow_app/features/devices/bloc/door_sensor_bloc/door_sensor_state.dart';
+import 'package:syncrow_app/features/devices/model/door_sensor_model.dart';
+import 'package:syncrow_app/features/shared_widgets/default_container.dart';
+import 'package:syncrow_app/features/shared_widgets/default_scaffold.dart';
+import 'package:syncrow_app/features/shared_widgets/text_widgets/body_large.dart';
+import 'package:syncrow_app/utils/resource_manager/color_manager.dart';
+
+class NotificationSettingsPage extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return DefaultScaffold(
+        title: 'Notification Settings',
+        child: BlocProvider(
+          create: (context) => DoorSensorBloc(switchCode: 'switch_1', DSId: '')
+            ..add(const DoorSensorInitial()),
+          child: BlocBuilder<DoorSensorBloc, DoorSensorState>(
+            builder: (context, state) {
+              final doorSensorBloc = BlocProvider.of<DoorSensorBloc>(context);
+              DoorSensorModel model = DoorSensorModel(
+                  batteryPercentage: 0, doorContactState: false);
+              if (state is LoadingNewSate) {
+                model = state.doorSensor;
+              } else if (state is UpdateState) {
+                model = state.doorSensor;
+              }
+              return state is DoorSensorLoadingState
+                  ? const Center(
+                      child: DefaultContainer(
+                          width: 50,
+                          height: 50,
+                          child: CircularProgressIndicator()),
+                    )
+                  : Column(
+                      children: [
+                        DefaultContainer(
+                          child: Column(
+                            mainAxisAlignment: MainAxisAlignment.start,
+                            mainAxisSize: MainAxisSize.min,
+                            crossAxisAlignment: CrossAxisAlignment.start,
+                            children: [
+                              SizedBox(
+                                height: 50,
+                                child: ListTile(
+                                  contentPadding: EdgeInsets.zero,
+                                  leading: const BodyLarge(
+                                    text: 'Low Battery',
+                                    fontWeight: FontWeight.normal,
+                                  ),
+                                  trailing: Transform.scale(
+                                      scale: .8,
+                                      child: CupertinoSwitch(
+                                        value: doorSensorBloc.lowBattery,
+                                        onChanged: (value) {
+                                          context.read<DoorSensorBloc>().add(
+                                              ToggleLowBatteryEvent(value));
+                                        },
+                                        applyTheme: true,
+                                      )),
+                                ),
+                              ),
+                              const Divider(
+                                color: ColorsManager.graysColor,
+                              ),
+                              SizedBox(
+                                height: 50,
+                                child: ListTile(
+                                  contentPadding: EdgeInsets.zero,
+                                  leading: const BodyLarge(
+                                    text: 'Closing Reminder',
+                                    fontWeight: FontWeight.normal,
+                                  ),
+                                  trailing: Transform.scale(
+                                      scale: .8,
+                                      child: CupertinoSwitch(
+                                        value: doorSensorBloc.closingReminder,
+                                        onChanged: (value) {
+                                          context.read<DoorSensorBloc>().add(
+                                              ToggleClosingReminderEvent(
+                                                  value));
+                                        },
+                                        applyTheme: true,
+                                      )),
+                                ),
+                              ),
+                              const Divider(
+                                color: ColorsManager.graysColor,
+                              ),
+                              SizedBox(
+                                height: 50,
+                                child: ListTile(
+                                  contentPadding: EdgeInsets.zero,
+                                  leading: const BodyLarge(
+                                    text: 'Door Alarm',
+                                    fontWeight: FontWeight.normal,
+                                  ),
+                                  trailing: Transform.scale(
+                                      scale: .8,
+                                      child: CupertinoSwitch(
+                                        value: doorSensorBloc.closingReminder,
+                                        onChanged: (value) {
+                                          context
+                                              .read<DoorSensorBloc>()
+                                              .add(ToggleDoorAlarmEvent(value));
+                                        },
+                                        applyTheme: true,
+                                      )),
+                                ),
+                              ),
+                            ],
+                          ),
+                        ),
+                      ],
+                    );
+            },
+          ),
+        ));
+  }
+}

lib/features/devices/view/widgets/door_sensor/door_records_screen.dart

@@ -0,0 +1,77 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:intl/intl.dart';
+import 'package:syncrow_app/features/devices/bloc/door_sensor_bloc/door_sensor_bloc.dart';
+import 'package:syncrow_app/features/devices/bloc/door_sensor_bloc/door_sensor_event.dart';
+import 'package:syncrow_app/features/devices/bloc/door_sensor_bloc/door_sensor_state.dart';
+import 'package:syncrow_app/features/shared_widgets/default_container.dart';
+import 'package:syncrow_app/features/shared_widgets/default_scaffold.dart';
+
+class DoorRecordsScreen extends StatelessWidget {
+   final  String DSId;
+  const DoorRecordsScreen({super.key,required this.DSId});
+
+  @override
+  Widget build(BuildContext context) {
+    return DefaultScaffold(
+        title: 'Records',
+        child: BlocProvider(
+            create: (context) =>
+                DoorSensorBloc(switchCode: 'switch_1', DSId:DSId )
+                  ..add(const ReportLogsInitial()),
+            child: BlocBuilder<DoorSensorBloc, DoorSensorState>(
+                builder: (context, state) {
+              final doorSensorBloc = BlocProvider.of<DoorSensorBloc>(context);
+              return SizedBox(
+                child: ListView.builder(
+                  itemCount: doorSensorBloc.recordGroups.length,
+                  itemBuilder: (context, index) {
+                    final recordGroup = doorSensorBloc.recordGroups[index];
+
+                    return Column(
+                      crossAxisAlignment: CrossAxisAlignment.start,
+                      children: [
+                        // Date header
+                        Padding(
+                          padding: const EdgeInsets.all(16.0),
+                          child: Text(
+                            DateFormat('EEEE, dd/MM/yyyy')
+                                .format(recordGroup.date),
+                            style: const TextStyle(
+                              fontSize: 18,
+                              fontWeight: FontWeight.bold,
+                            ),
+                          ),
+                        ),
+                        // Display each record for the date
+                        DefaultContainer(
+                          child: Column(
+                            children: recordGroup.records.map((record) {
+                              return ListTile(
+                                leading: Icon(
+                                  record.isOpen
+                                      ? Icons.radio_button_checked
+                                      : Icons.radio_button_unchecked,
+                                  color:
+                                      record.isOpen ? Colors.blue : Colors.grey,
+                                ),
+                                title: Text(
+                                  record.status,
+                                  style: const TextStyle(
+                                    fontWeight: FontWeight.bold,
+                                    fontSize: 18,
+                                  ),
+                                ),
+                                subtitle: Text(record.time),
+                              );
+                            }).toList(),
+                          ),
+                        ),
+                      ],
+                    );
+                  },
+                ),
+              );
+            })));
+  }
+}

lib/features/devices/view/widgets/door_sensor/door_sensor_screen.dart

@@ -0,0 +1,207 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:flutter_svg/flutter_svg.dart';
+import 'package:syncrow_app/features/devices/bloc/door_sensor_bloc/door_sensor_bloc.dart';
+import 'package:syncrow_app/features/devices/bloc/door_sensor_bloc/door_sensor_event.dart';
+import 'package:syncrow_app/features/devices/bloc/door_sensor_bloc/door_sensor_state.dart';
+import 'package:syncrow_app/features/devices/model/device_model.dart';
+import 'package:syncrow_app/features/devices/model/door_sensor_model.dart';
+import 'package:syncrow_app/features/devices/view/widgets/door_sensor/door_notification_settings.dart';
+import 'package:syncrow_app/features/devices/view/widgets/door_sensor/door_records_screen.dart';
+import 'package:syncrow_app/features/shared_widgets/battery_bar.dart';
+import 'package:syncrow_app/features/shared_widgets/default_container.dart';
+import 'package:syncrow_app/features/shared_widgets/default_scaffold.dart';
+import 'package:syncrow_app/features/shared_widgets/text_widgets/body_small.dart';
+import 'package:syncrow_app/generated/assets.dart';
+
+class DoorSensorScreen extends StatelessWidget {
+  final DeviceModel? device;
+
+  const DoorSensorScreen({super.key, this.device});
+
+  @override
+  Widget build(BuildContext context) {
+    return DefaultScaffold(
+      title: 'Door Sensor',
+      child: BlocProvider(
+        create: (context) =>
+            DoorSensorBloc(switchCode: 'switch_1', DSId: device?.uuid ?? '')
+              ..add(const DoorSensorInitial()),
+        child: BlocBuilder<DoorSensorBloc, DoorSensorState>(
+          builder: (context, state) {
+            final doorSensorBloc = BlocProvider.of<DoorSensorBloc>(context);
+            DoorSensorModel model =
+                DoorSensorModel(batteryPercentage: 0, doorContactState: false);
+            if (state is LoadingNewSate) {
+              model = state.doorSensor;
+            } else if (state is UpdateState) {
+              model = state.doorSensor;
+            }
+            return state is DoorSensorLoadingState
+                ? const Center(
+                    child: DefaultContainer(
+                        width: 50,
+                        height: 50,
+                        child: CircularProgressIndicator()),
+                  )
+                : RefreshIndicator(
+                    onRefresh: () async {
+                      doorSensorBloc.add(const DoorSensorInitial());
+                    },
+                    child: Center(
+                      child: ListView(
+                        shrinkWrap: true,
+                        children: [
+                          Column(
+                            mainAxisAlignment: MainAxisAlignment.center,
+                            children: [
+                              BatteryBar(
+                                batteryPercentage: model.batteryPercentage,
+                              ),
+                              InkWell(
+                                overlayColor:
+                                    WidgetStateProperty.all(Colors.transparent),
+                                onTap: () {
+                              
+                                },
+                                child: Row(
+                                  mainAxisAlignment: MainAxisAlignment.center,
+                                  crossAxisAlignment: CrossAxisAlignment.center,
+                                  children: [
+                                    Container(
+                                      decoration: BoxDecoration(
+                                        // color: Colors.white.withOpacity(0.1),
+                                        borderRadius:
+                                            BorderRadius.circular(890),
+                                        boxShadow: [
+                                          BoxShadow(
+                                            color:
+                                                Colors.white.withOpacity(0.1),
+                                            blurRadius: 24,
+                                            offset: const Offset(-5, -5),
+                                            blurStyle: BlurStyle.outer,
+                                          ),
+                                          BoxShadow(
+                                            color:
+                                                Colors.black.withOpacity(0.11),
+                                            blurRadius: 25,
+                                            offset: const Offset(5, 5),
+                                            blurStyle: BlurStyle.outer,
+                                          ),
+                                          BoxShadow(
+                                            color:
+                                                Colors.black.withOpacity(0.13),
+                                            blurRadius: 30,
+                                            offset: const Offset(5, 5),
+                                            blurStyle: BlurStyle.inner,
+                                          ),
+                                        ],
+                                      ),
+                                      child: SvgPicture.asset(
+                                        model.doorContactState
+                                            ? Assets.doorOpen
+                                            : Assets.doorClose,
+                                        fit: BoxFit.fill,
+                                      ),
+                                    ),
+                                  ],
+                                ),
+                              ),
+                              const SizedBox(height: 80),
+                            ],
+                          ),
+                          SizedBox(
+                            height: MediaQuery.of(context).size.height * 0.13,
+                            child: Row(
+                              children: [
+                                Expanded(
+                                  child: DefaultContainer(
+                                    onTap: () {
+                                      Navigator.of(context).push(
+                                        MaterialPageRoute(
+                                            builder: (context) =>
+                                                DoorRecordsScreen(
+                                                    DSId: device!.uuid!)),
+                                      );
+                                    },
+                                    child: Column(
+                                      crossAxisAlignment:
+                                          CrossAxisAlignment.center,
+                                      mainAxisAlignment:
+                                          MainAxisAlignment.center,
+                                      children: [
+                                        ConstrainedBox(
+                                          constraints: const BoxConstraints(
+                                              maxHeight: 46, maxWidth: 50),
+                                          child: SvgPicture.asset(
+                                              Assets.doorRecordsIcon),
+                                        ),
+                                        const SizedBox(
+                                          height: 15,
+                                        ),
+                                        const Flexible(
+                                          child: FittedBox(
+                                            child: BodySmall(
+                                              text: 'Records',
+                                              // doorLockButtons.keys.elementAt(index),
+                                              textAlign: TextAlign.center,
+                                            ),
+                                          ),
+                                        ),
+                                      ],
+                                    ),
+                                  ),
+                                ),
+                                const SizedBox(
+                                  width: 10,
+                                ),
+                                Expanded(
+                                  child: DefaultContainer(
+                                    onTap: () {
+                                      Navigator.of(context).push(
+                                        MaterialPageRoute(
+                                            builder: (context) =>
+                                                NotificationSettingsPage()),
+                                      );
+                                    },
+                                    child: Column(
+                                      crossAxisAlignment:
+                                          CrossAxisAlignment.center,
+                                      mainAxisAlignment:
+                                          MainAxisAlignment.center,
+                                      children: [
+                                        ConstrainedBox(
+                                          constraints: const BoxConstraints(
+                                              maxHeight: 46, maxWidth: 50),
+                                          child: SvgPicture.asset(
+                                              Assets.doorNotificationSetting),
+                                        ),
+                                        const SizedBox(
+                                          height: 15,
+                                        ),
+                                        const Flexible(
+                                          child: FittedBox(
+                                            child: BodySmall(
+                                              text: 'Notification Settings',
+                                              // doorLockButtons.keys.elementAt(index),
+                                              textAlign: TextAlign.center,
+                                            ),
+                                          ),
+                                        ),
+                                      ],
+                                    ),
+                                  ),
+                                ),
+                              ],
+                            ),
+                          )
+                        ],
+                      ),
+                    ),
+                  );
+          },
+        ),
+      ),
+    );
+  }
+}

lib/features/devices/view/widgets/room_page_switch.dart

@@ -9,10 +9,10 @@ import 'package:syncrow_app/features/devices/bloc/devices_cubit.dart';
 import 'package:syncrow_app/features/devices/model/device_model.dart';
 import 'package:syncrow_app/features/devices/view/widgets/ACs/acs_view.dart';
 import 'package:syncrow_app/features/devices/view/widgets/curtains/curtain_view.dart';
+import 'package:syncrow_app/features/devices/view/widgets/door_sensor/door_sensor_screen.dart';
 import 'package:syncrow_app/features/devices/view/widgets/gateway/gateway_view.dart';
 import 'package:syncrow_app/features/devices/view/widgets/lights/light_interface.dart';
 import 'package:syncrow_app/features/devices/view/widgets/one_gang/one_gang_Interface.dart';
-import 'package:syncrow_app/features/devices/view/widgets/one_gang/one_gang_screen.dart';
 import 'package:syncrow_app/features/devices/view/widgets/two_gang/two_gang_Interface.dart';
 import 'package:syncrow_app/features/devices/view/widgets/wall_sensor/wall_sensor_interface.dart';
 import 'package:syncrow_app/features/devices/view/widgets/ceiling_sensor/ceiling_sensor_interface.dart';
@@ -31,7 +31,6 @@ class RoomPageSwitch extends StatelessWidget {
   });
 
   final DeviceModel device;
-
   @override
   Widget build(BuildContext context) {
     return GestureDetector(
@@ -87,7 +86,8 @@ void showDeviceInterface(DeviceModel device, BuildContext context) {
       Navigator.push(
           context,
           PageRouteBuilder(
-              pageBuilder: (context, animation1, animation2) => ACsView(deviceModel: device)));
+              pageBuilder: (context, animation1, animation2) =>
+                  ACsView(deviceModel: device)));
       // navigateToInterface(ACsView(deviceModel: device), context);
       break;
     case DeviceType.WallSensor:
@@ -110,8 +110,9 @@ void showDeviceInterface(DeviceModel device, BuildContext context) {
       Navigator.push(
           context,
           PageRouteBuilder(
-              pageBuilder: (context, animation1, animation2) =>
-                  CurtainView(curtain: device,)));
+              pageBuilder: (context, animation1, animation2) => CurtainView(
+                    curtain: device,
+                  )));
       break;
     case DeviceType.Blind:
       break;
@@ -119,14 +120,16 @@ void showDeviceInterface(DeviceModel device, BuildContext context) {
       Navigator.push(
           context,
           PageRouteBuilder(
-              pageBuilder: (context, animation1, animation2) => DoorInterface(doorLock: device)));
+              pageBuilder: (context, animation1, animation2) =>
+                  DoorInterface(doorLock: device)));
       // navigateToInterface(DoorInterface(doorlock: device), context);
       break;
     case DeviceType.Gateway:
       Navigator.push(
           context,
           PageRouteBuilder(
-              pageBuilder: (context, animation1, animation2) => GateWayView(gatewayObj: device)));
+              pageBuilder: (context, animation1, animation2) =>
+                  GateWayView(gatewayObj: device)));
       break;
     case DeviceType.LightBulb:
       navigateToInterface(LightInterface(light: device), context);
@@ -149,13 +152,18 @@ void showDeviceInterface(DeviceModel device, BuildContext context) {
               pageBuilder: (context, animation1, animation2) =>
                   ThreeGangInterface(gangSwitch: device)));
 
-
-      case DeviceType.WH:
+    case DeviceType.WH:
       Navigator.push(
           context,
           PageRouteBuilder(
               pageBuilder: (context, animation1, animation2) =>
                   WaterHeaterPage(device: device)));
+    case DeviceType.DS:
+      Navigator.push(
+          context,
+          PageRouteBuilder(
+              pageBuilder: (context, animation1, animation2) =>
+                  DoorSensorScreen(device: device)));
       break;
     default:
   }

lib/features/shared_widgets/battery_bar.dart

@@ -0,0 +1,57 @@
+    import 'package:flutter/material.dart';
+
+
+
+
+class BatteryBar extends StatelessWidget {
+  const BatteryBar({
+    required this.batteryPercentage,
+    super.key,
+  });
+
+  final int batteryPercentage;
+  @override
+  Widget build(BuildContext context) {
+    return Row(
+      mainAxisAlignment: MainAxisAlignment.spaceBetween,
+      children: [
+        SizedBox(),
+        Transform.rotate(
+          angle: 1.5708, // 90 degrees in radians (π/2 or 1.5708)
+          child: Icon(
+            _getBatteryIcon(batteryPercentage),
+            color: _getBatteryColor(batteryPercentage),
+            size: 30,
+          ),
+        ),
+      ],
+    );
+  }
+
+  IconData _getBatteryIcon(int batteryLevel) {
+    // if (batteryState == BatteryState.charging) {
+    //   return Icons.battery_charging_full;
+    // } else
+    if (batteryLevel >= 80) {
+      return Icons.battery_full;
+    } else if (batteryLevel >= 60) {
+      return Icons.battery_4_bar;
+    } else if (batteryLevel >= 40) {
+      return Icons.battery_3_bar;
+    } else if (batteryLevel >= 20) {
+      return Icons.battery_2_bar;
+    } else {
+      return Icons.battery_alert;
+    }
+  }
+
+  Color _getBatteryColor(int batteryLevel) {
+    if (batteryLevel >= 80) {
+      return Colors.green;
+    } else if (batteryLevel >= 40) {
+      return Colors.yellowAccent;
+    } else {
+      return Colors.red;
+    }
+  }
+}