Merge pull request #41 from SyncrowIOT/autoamtion_fixes

Autoamtion fixes

lib/features/app_layout/bloc/home_cubit.dart

@@ -18,8 +18,11 @@ import 'package:syncrow_app/features/devices/view/widgets/curtains/curtain_view.
 import 'package:syncrow_app/features/devices/view/widgets/devices_view_body.dart';
 import 'package:syncrow_app/features/menu/view/menu_view.dart';
 import 'package:syncrow_app/features/scene/bloc/create_scene/create_scene_bloc.dart';
+import 'package:syncrow_app/features/scene/bloc/effective_period/effect_period_bloc.dart';
+import 'package:syncrow_app/features/scene/bloc/effective_period/effect_period_event.dart';
 import 'package:syncrow_app/features/scene/bloc/smart_scene/smart_scene_select_dart_bloc.dart';
 import 'package:syncrow_app/features/scene/enum/create_scene_enum.dart';
+import 'package:syncrow_app/features/scene/model/create_automation_model.dart';
 import 'package:syncrow_app/features/scene/model/scene_settings_route_arguments.dart';
 import 'package:syncrow_app/features/scene/view/create_scene_view.dart';
 import 'package:syncrow_app/features/scene/view/scene_tasks_view.dart';
@@ -385,6 +388,9 @@ class HomeCubit extends Cubit<HomeState> {
           NavigationService.navigatorKey.currentContext!
               .read<SmartSceneSelectBloc>()
               .add(const SmartSceneClearEvent());
+          BlocProvider.of<EffectPeriodBloc>(
+                  NavigationService.navigatorKey.currentState!.context)
+              .add(ResetEffectivePeriod());
         },
       ),
       IconButton(

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

@@ -1,6 +1,9 @@
 import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:syncrow_app/features/scene/bloc/create_scene/create_scene_bloc.dart';
+import 'package:syncrow_app/features/scene/bloc/effective_period/effect_period_bloc.dart';
+import 'package:syncrow_app/features/scene/bloc/effective_period/effect_period_event.dart';
+import 'package:syncrow_app/features/scene/bloc/smart_scene/smart_scene_select_dart_bloc.dart';
 import 'package:syncrow_app/features/scene/enum/create_scene_enum.dart';
 import 'package:syncrow_app/features/scene/model/scene_settings_route_arguments.dart';
 import 'package:syncrow_app/features/scene/model/scenes_model.dart';

lib/features/scene/bloc/create_scene/create_scene_bloc.dart

@@ -92,30 +92,59 @@ class CreateSceneBloc extends Bloc<CreateSceneEvent, CreateSceneState>
       TempHoldSceneTasksEvent event, Emitter<CreateSceneState> emit) {
     emit(CreateSceneLoading());
     bool updated = false;
+
+    // Check and update if the task exists in tempTasksList
     for (var element in tempTasksList) {
-      if (element.code == event.deviceControlModel.code) {
+      var updatedElement = element.copyWith(
-        // Update the existing function with new values
+        operationName: event.operation,
-        var updatedElement = element.copyWith(
+        deviceName: event.deviceName,
-          operationName: event.operation,
+        icon: event.icon,
-          deviceName: event.deviceName,
+        code: event.deviceControlModel.code ?? '',
-          icon: event.icon,
+        deviceId: event.deviceId,
-          code: event.deviceControlModel.code ?? '',
+        functionValue: event.deviceControlModel.value,
-          deviceId: event.deviceId,
+        operationDialogType: event.operationType,
-          functionValue: event.deviceControlModel.value,
+        operationalValues: [
-          operationDialogType: event.operationType,
+          SceneOperationalValue(
-          operationalValues: [
+            value: event.deviceControlModel.value,
-            SceneOperationalValue(
+            icon: '',
-              value: event.deviceControlModel.value,
+          ),
-              icon: '',
+        ],
-            ),
+      );
-          ],
+      tempTasksList[tempTasksList.indexOf(element)] = updatedElement;
-        );
+      selectedValues[updatedElement.code] = event.deviceControlModel.value;
-        tempTasksList[tempTasksList.indexOf(element)] = updatedElement;
+      updated = true;
-        selectedValues[updatedElement.code] = event.deviceControlModel.value;
+      break;
-        updated = true;
+    }
-        break;
+
+    if (!updated) {
+      /// for smart scene add to view
+      for (var element in tasksList) {
+        if (element.deviceId == event.deviceControlModel.deviceId &&
+            element.code == event.deviceControlModel.code) {
+          var updatedElement = element.copyWith(
+            operationName: event.operation,
+            deviceName: event.deviceName,
+            icon: event.icon,
+            code: event.deviceControlModel.code ?? '',
+            deviceId: event.deviceId,
+            functionValue: event.deviceControlModel.value,
+            operationDialogType: event.operationType,
+            operationalValues: [
+              SceneOperationalValue(
+                value: event.deviceControlModel.value,
+                icon: '',
+              ),
+            ],
+          );
+          tasksList[tasksList.indexOf(element)] = updatedElement;
+          selectedValues[updatedElement.code] = event.deviceControlModel.value;
+          updated = true;
+          break;
+        }
       }
     }
+
+    // Add new element if it doesn't exist in either list
     if (!updated) {
       var newElement = SceneStaticFunction(
         operationName: event.operation,
@@ -319,7 +348,8 @@ class CreateSceneBloc extends Bloc<CreateSceneEvent, CreateSceneState>
         automationTempTasksList.clear();
         automationSelectedValues.clear();
         automationComparatorValues.clear();
-        effectiveTime = null;
+        effectiveTime =
+            EffectiveTime(start: '00:00', end: '23:59', loops: '1111111');
         sceneType = CreateSceneEnum.none;
         conditionRule = 'or';
         emit(const CreateSceneWithTasks(success: true));
@@ -369,14 +399,31 @@ class CreateSceneBloc extends Bloc<CreateSceneEvent, CreateSceneState>
 
           conditionRule = response.decisionExpr ?? conditionRule;
 
-          if (response.effectiveTime != null) {
+          effectiveTime = response.effectiveTime != null
-            BlocProvider.of<EffectPeriodBloc>(
+              ? EffectiveTime(
-                    NavigationService.navigatorKey.currentState!.context)
+                  start: response.effectiveTime!.start,
-                .add(SetCustomTime(response.effectiveTime!.start,
+                  end: response.effectiveTime!.end,
-                    response.effectiveTime!.end));
+                  loops: response.effectiveTime!.loops,
-            BlocProvider.of<EffectPeriodBloc>(
+                )
-                    NavigationService.navigatorKey.currentState!.context)
+              : EffectiveTime(start: '00:00', end: '23:59', loops: '1111111');
-                .add(ToggleDay(response.effectiveTime!.loops));
+
+          // Set Custom Time and reset days first
+          BlocProvider.of<EffectPeriodBloc>(
+                  NavigationService.navigatorKey.currentContext!)
+              .add(SetCustomTime(effectiveTime!.start, effectiveTime!.end));
+
+          // Reset all days to not selected before toggling
+          BlocProvider.of<EffectPeriodBloc>(
+                  NavigationService.navigatorKey.currentContext!)
+              .add(ResetDays());
+
+          // Iterate over the loops and toggle each day
+          for (int i = 0; i < effectiveTime!.loops.length; i++) {
+            if (effectiveTime!.loops[i] == '1') {
+              BlocProvider.of<EffectPeriodBloc>(
+                      NavigationService.navigatorKey.currentContext!)
+                  .add(ToggleDay(_getDayFromIndex(i)));
+            }
           }
 
           emit(AddSceneTask(
@@ -401,6 +448,11 @@ class CreateSceneBloc extends Bloc<CreateSceneEvent, CreateSceneState>
     }
   }
 
+  String _getDayFromIndex(int index) {
+    const days = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'];
+    return days[index];
+  }
+
   FutureOr<void> _clearTempTaskList(
       ClearTempTaskListEvent event, Emitter<CreateSceneState> emit) {
     emit(CreateSceneLoading());
@@ -408,20 +460,15 @@ class CreateSceneBloc extends Bloc<CreateSceneEvent, CreateSceneState>
       automationTempTasksList.clear();
       automationSelectedValues.clear();
       automationComparatorValues.clear();
-      emit(AddSceneTask(
-        tasksList: tasksList,
-        automationTasksList: automationTasksList,
-        condition: conditionRule,
-      ));
     } else {
       tempTasksList.clear();
       selectedValues.clear();
-      emit(AddSceneTask(
-        tasksList: tasksList,
-        automationTasksList: automationTasksList,
-        condition: conditionRule,
-      ));
     }
+    emit(AddSceneTask(
+      tasksList: tasksList,
+      automationTasksList: automationTasksList,
+      condition: conditionRule,
+    ));
   }
 
   FutureOr<void> _removeFromSelectedValueById(

lib/features/scene/bloc/effective_period/effect_period_bloc.dart

@@ -12,6 +12,8 @@ class EffectPeriodBloc extends Bloc<EffectPeriodEvent, EffectPeriodState> {
     on<SetPeriod>(_onSetPeriod);
     on<ToggleDay>(_onToggleDay);
     on<SetCustomTime>(_onSetCustomTime);
+    on<ResetEffectivePeriod>(_onResetEffectivePeriod);
+    on<ResetDays>(_onResetDays);
   }
 
   void _onSetPeriod(SetPeriod event, Emitter<EffectPeriodState> emit) {
@@ -39,13 +41,15 @@ class EffectPeriodBloc extends Bloc<EffectPeriodEvent, EffectPeriodState> {
         break;
     }
 
-    // Update CreateSceneBloc
     BlocProvider.of<CreateSceneBloc>(
-            NavigationService.navigatorKey.currentState!.context)
+            NavigationService.navigatorKey.currentContext!)
         .add(EffectiveTimePeriodEvent(EffectiveTime(
             start: startTime, end: endTime, loops: state.selectedDaysBinary)));
 
-    emit(state.copyWith(selectedPeriod: event.period));
+    emit(state.copyWith(
+        selectedPeriod: event.period,
+        customStartTime: startTime,
+        customEndTime: endTime));
   }
 
   void _onToggleDay(ToggleDay event, Emitter<EffectPeriodState> emit) {
@@ -60,7 +64,7 @@ class EffectPeriodBloc extends Bloc<EffectPeriodEvent, EffectPeriodState> {
     emit(state.copyWith(selectedDaysBinary: newDaysBinary));
 
     BlocProvider.of<CreateSceneBloc>(
-            NavigationService.navigatorKey.currentState!.context)
+            NavigationService.navigatorKey.currentContext!)
         .add(EffectiveTimePeriodEvent(EffectiveTime(
             start: state.customStartTime ?? '00:00',
             end: state.customEndTime ?? '23:59',
@@ -68,15 +72,48 @@ class EffectPeriodBloc extends Bloc<EffectPeriodEvent, EffectPeriodState> {
   }
 
   void _onSetCustomTime(SetCustomTime event, Emitter<EffectPeriodState> emit) {
+    String startTime = event.startTime;
+    String endTime = event.endTime;
+    EnumEffectivePeriodOptions period;
+
+    // Determine the period based on start and end times
+    if (startTime == '00:00' && endTime == '23:59') {
+      period = EnumEffectivePeriodOptions.allDay;
+    } else if (startTime == '06:00' && endTime == '18:00') {
+      period = EnumEffectivePeriodOptions.daytime;
+    } else if (startTime == '18:00' && endTime == '06:00') {
+      period = EnumEffectivePeriodOptions.night;
+    } else {
+      period = EnumEffectivePeriodOptions.custom;
+    }
+
     emit(state.copyWith(
-        customStartTime: event.startTime, customEndTime: event.endTime));
+        customStartTime: startTime,
+        customEndTime: endTime,
+        selectedPeriod: period));
 
     BlocProvider.of<CreateSceneBloc>(
-            NavigationService.navigatorKey.currentState!.context)
+            NavigationService.navigatorKey.currentContext!)
         .add(EffectiveTimePeriodEvent(EffectiveTime(
-            start: event.startTime,
+            start: startTime, end: endTime, loops: state.selectedDaysBinary)));
-            end: event.endTime,
+  }
-            loops: state.selectedDaysBinary)));
+
+  void _onResetEffectivePeriod(
+      ResetEffectivePeriod event, Emitter<EffectPeriodState> emit) {
+    emit(state.copyWith(
+        selectedPeriod: EnumEffectivePeriodOptions.allDay,
+        customStartTime: '00:00',
+        customEndTime: '23:59',
+        selectedDaysBinary: '1111111'));
+
+    BlocProvider.of<CreateSceneBloc>(
+            NavigationService.navigatorKey.currentContext!)
+        .add(EffectiveTimePeriodEvent(
+            EffectiveTime(start: '00:00', end: '23:59', loops: '1111111')));
+  }
+
+  void _onResetDays(ResetDays event, Emitter<EffectPeriodState> emit) {
+    emit(state.copyWith(selectedDaysBinary: '1111111'));
   }
 
   int _getDayIndex(String day) {

lib/features/scene/bloc/effective_period/effect_period_event.dart

@@ -35,3 +35,10 @@ class SetCustomTime extends EffectPeriodEvent {
   @override
   List<Object> get props => [startTime, endTime];
 }
+
+class ResetEffectivePeriod extends EffectPeriodEvent {}
+
+class ResetDays extends EffectPeriodEvent {
+  @override
+  List<Object> get props => [];
+}

lib/features/scene/bloc/effective_period/effect_period_state.dart

@@ -37,6 +37,18 @@ class EffectPeriodState extends Equatable {
     );
   }
 
+  EnumEffectivePeriodOptions getEffectivePeriod() {
+    if (customStartTime == '00:00' && customEndTime == '23:59') {
+      return EnumEffectivePeriodOptions.allDay;
+    } else if (customStartTime == '06:00' && customEndTime == '18:00') {
+      return EnumEffectivePeriodOptions.daytime;
+    } else if (customStartTime == '18:00' && customEndTime == '06:00') {
+      return EnumEffectivePeriodOptions.night;
+    } else {
+      return EnumEffectivePeriodOptions.custom;
+    }
+  }
+
   @override
   List<Object?> get props =>
       [selectedPeriod, selectedDaysBinary, customStartTime, customEndTime];

lib/features/scene/bloc/smart_scene/smart_scene_select_dart_bloc.dart

@@ -2,8 +2,14 @@ import 'dart:async';
 
 import 'package:bloc/bloc.dart';
 import 'package:equatable/equatable.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:syncrow_app/features/devices/model/device_control_model.dart';
+import 'package:syncrow_app/features/scene/bloc/create_scene/create_scene_bloc.dart';
+import 'package:syncrow_app/features/scene/enum/create_scene_enum.dart';
+import 'package:syncrow_app/features/scene/enum/operation_dialog_type.dart';
 import 'package:syncrow_app/features/scene/model/smart_scene_enable.dart';
-
+import 'package:syncrow_app/generated/assets.dart';
+import 'package:syncrow_app/navigation/navigation_service.dart';
 part 'smart_scene_select_dart_event.dart';
 part 'smart_scene_select_dart_state.dart';
 
@@ -12,6 +18,7 @@ class SmartSceneSelectBloc
   SmartSceneSelectBloc() : super(SmartSceneSelectInitial()) {
     on<SmartSceneEnableEvent>(_onSmartSceneEnable);
     on<SmartSceneClearEvent>(_smartSceneClear);
+    on<SmartSceneConfirmSelectionEvent>(_smartSceneConfirmSelection);
   }
 
   SmartSceneEnable? smartSceneEnable;
@@ -19,7 +26,6 @@ class SmartSceneSelectBloc
   FutureOr<void> _onSmartSceneEnable(
       SmartSceneEnableEvent event, Emitter<SmartSceneSelectState> emit) {
     smartSceneEnable = event.smartSceneEnable;
-    emit(SmartSceneSelected(smartSceneEnable: smartSceneEnable!));
   }
 
   FutureOr<void> _smartSceneClear(
@@ -27,4 +33,33 @@ class SmartSceneSelectBloc
     smartSceneEnable = null;
     emit(SmartSceneSelectInitial());
   }
-}
+
+  FutureOr<void> _smartSceneConfirmSelection(
+      SmartSceneConfirmSelectionEvent event,
+      Emitter<SmartSceneSelectState> emit) {
+    final createSceneBloc = NavigationService.navigatorKey.currentState!.context
+        .read<CreateSceneBloc>();
+
+    createSceneBloc.add(TempHoldSceneTasksEvent(
+      deviceControlModel: DeviceControlModel(
+        deviceId: smartSceneEnable?.entityId ?? '',
+        code: CreateSceneEnum.smartSceneSelect.name,
+        value: smartSceneEnable?.actionExecutor ?? '',
+      ),
+      deviceId: smartSceneEnable?.entityId ?? '',
+      operation: smartSceneEnable?.type ?? '',
+      icon: smartSceneEnable?.isAutomation == true
+          ? Assets.player
+          : Assets.handClickIcon,
+      deviceName: smartSceneEnable?.sceneORAutomationName ?? '',
+      uniqueId: smartSceneEnable?.entityId ?? '',
+      operationType: OperationDialogType.none,
+      isAutomation: false,
+    ));
+
+    emit(SmartSceneSelected(smartSceneEnable: smartSceneEnable!));
+    NavigationService.navigatorKey.currentState!.context
+        .read<CreateSceneBloc>()
+        .add(const AddTaskEvent(isAutomation: false));
+  }
+}

lib/features/scene/bloc/smart_scene/smart_scene_select_dart_event.dart

@@ -19,3 +19,7 @@ class SmartSceneEnableEvent extends SmartSceneSelectEvent {
 class SmartSceneClearEvent extends SmartSceneSelectEvent {
   const SmartSceneClearEvent();
 }
+
+class SmartSceneConfirmSelectionEvent extends SmartSceneSelectEvent {
+  const SmartSceneConfirmSelectionEvent();
+}

lib/features/scene/enum/create_scene_enum.dart

@@ -1,5 +1,6 @@
 enum CreateSceneEnum {
   tabToRun,
   deviceStatusChanges,
+  smartSceneSelect,
   none,
 }

lib/features/scene/helper/scene_logic_helper.dart

@@ -2,7 +2,7 @@ import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:syncrow_app/features/app_layout/bloc/home_cubit.dart';
 import 'package:syncrow_app/features/scene/bloc/create_scene/create_scene_bloc.dart';
-import 'package:syncrow_app/features/scene/bloc/smart_scene/smart_scene_select_dart_bloc.dart';
+import 'package:syncrow_app/features/scene/enum/create_scene_enum.dart';
 import 'package:syncrow_app/features/scene/enum/operation_dialog_type.dart';
 import 'package:syncrow_app/features/scene/model/create_automation_model.dart';
 import 'package:syncrow_app/features/scene/model/create_scene_model.dart';
@@ -30,144 +30,128 @@ mixin SceneLogicHelper {
     required List<SceneStaticFunction> conditions,
   }) {
     final sceneBloc = context.read<CreateSceneBloc>();
-    final smartSceneBloc = context.read<SmartSceneSelectBloc>();
+
+    if (isOnlyDelayOrDelayLast(actions)) {
+      context.showCustomSnackbar(
+        message: 'A single delay or delay-last operations are NOT allowed.',
+        icon: const Icon(
+          Icons.error,
+          color: Colors.red,
+        ),
+      );
+      return;
+    }
 
     if (isAutomation) {
-      // Handle Automation Creation
+      final createAutomationModel = CreateAutomationModel(
-      if (isOnlyDelayOrDelayLast(actions)) {
+        unitUuid: HomeCubit.getInstance().selectedSpace!.id ?? '',
-        Navigator.pop(context);
+        automationName: sceneName.text,
-        context.showCustomSnackbar(
+        decisionExpr: sceneBloc.conditionRule,
-          message: 'A single delay or delay-last operations are NOT allowed.',
+        effectiveTime: sceneBloc.effectiveTime ??
-          icon: const Icon(
+            EffectiveTime(start: '00:00', end: '23:59', loops: '1111111'),
-            Icons.error,
+        conditions: List.generate(
-            color: Colors.red,
+          conditions.length,
-          ),
+          (index) {
-        );
+            final task = conditions[index];
-      } else {
+            return CreateCondition(
-        final createAutomationModel = CreateAutomationModel(
+              code: index + 1,
-          unitUuid: HomeCubit.getInstance().selectedSpace!.id ?? '',
+              entityId: task.deviceId,
-          automationName: sceneName.text,
+              entityType: 'device_report',
-          decisionExpr: sceneBloc.conditionRule,
+              expr: ConditionExpr(
-          effectiveTime: sceneBloc.effectiveTime ??
+                statusCode: task.code,
-              EffectiveTime(start: '00:00', end: '23:59', loops: '1111111'),
+                comparator: task.comparator ?? '==',
-          conditions: List.generate(
+                statusValue: task.functionValue,
-            conditions.length,
+              ),
+            );
+          },
+        ),
+        actions: [
+          ...List.generate(
+            actions.length,
             (index) {
-              final task = conditions[index];
+              final task = actions[index];
-              return CreateCondition(
+              if (task.deviceId == 'delay') {
-                code: index + 1,
+                return CreateSceneAction(
+                  entityId: actions[index].deviceId,
+                  actionExecutor: 'delay',
+                  executorProperty: CreateSceneExecutorProperty(
+                    functionCode: '',
+                    functionValue: '',
+                    delaySeconds: task.functionValue,
+                  ),
+                );
+              }
+              if (task.code == CreateSceneEnum.smartSceneSelect.name) {
+                return CreateSceneAction(
+                    entityId: actions[index].deviceId,
+                    actionExecutor: actions[index].functionValue,
+                    executorProperty: null);
+              }
+              return CreateSceneAction(
                 entityId: task.deviceId,
-                entityType: 'device_report',
+                actionExecutor: 'device_issue',
-                expr: ConditionExpr(
+                executorProperty: CreateSceneExecutorProperty(
-                  statusCode: task.code,
+                  functionCode: task.code,
-                  comparator: task.comparator ?? '==',
+                  functionValue: task.functionValue,
-                  statusValue: task.functionValue,
+                  delaySeconds: 0,
                 ),
               );
             },
           ),
-          actions: [
+        ],
-            ...List.generate(
+      );
-              actions.length,
+      sceneBloc.add(CreateSceneWithTasksEvent(
-              (index) {
+        createSceneModel: null,
-                final task = actions[index];
+        updateScene: updateScene,
-                if (task.deviceId == 'delay') {
+        sceneId: sceneId,
-                  return CreateSceneAction(
+        createAutomationModel: createAutomationModel,
-                    entityId: actions[index].deviceId,
+      ));
-                    actionExecutor: 'delay',
-                    executorProperty: CreateSceneExecutorProperty(
-                      functionCode: '',
-                      functionValue: '',
-                      delaySeconds: task.functionValue,
-                    ),
-                  );
-                }
-                return CreateSceneAction(
-                  entityId: task.deviceId,
-                  actionExecutor: 'device_issue',
-                  executorProperty: CreateSceneExecutorProperty(
-                    functionCode: task.code,
-                    functionValue: task.functionValue,
-                    delaySeconds: 0,
-                  ),
-                );
-              },
-            ),
-            if (smartSceneBloc.smartSceneEnable != null)
-              CreateSceneAction(
-                  entityId: smartSceneBloc.smartSceneEnable?.entityId ?? '',
-                  actionExecutor:
-                      smartSceneBloc.smartSceneEnable?.actionExecutor ?? '',
-                  executorProperty: null)
-          ],
-        );
-        sceneBloc.add(CreateSceneWithTasksEvent(
-          createSceneModel: null,
-          updateScene: updateScene,
-          sceneId: sceneId,
-          createAutomationModel: createAutomationModel,
-        ));
-        Navigator.pop(context);
-      }
     } else {
-      if (isOnlyDelayOrDelayLast(actions)) {
+      final createSceneModel = CreateSceneModel(
-        Navigator.pop(context);
+        unitUuid: HomeCubit.getInstance().selectedSpace!.id ?? '',
-        context.showCustomSnackbar(
+        sceneName: sceneName.text,
-          message: 'A single delay or delay-last operations are NOT allowed.',
+        decisionExpr: 'and',
-          icon: const Icon(
+        actions: [
-            Icons.error,
+          ...List.generate(
-            color: Colors.red,
+            actions.length,
-          ),
+            (index) {
-        );
+              final task = actions[index];
-      } else {
+              if (task.deviceId == 'delay') {
-        // Handle Scene Creation
-        final createSceneModel = CreateSceneModel(
-          unitUuid: HomeCubit.getInstance().selectedSpace!.id ?? '',
-          sceneName: sceneName.text,
-          decisionExpr: 'and',
-          actions: [
-            ...List.generate(
-              actions.length,
-              (index) {
-                final task = actions[index];
-                if (task.deviceId == 'delay') {
-                  return CreateSceneAction(
-                    entityId: actions[index].deviceId,
-                    actionExecutor: 'delay',
-                    executorProperty: CreateSceneExecutorProperty(
-                      functionCode: '',
-                      functionValue: '',
-                      delaySeconds: task.functionValue,
-                    ),
-                  );
-                }
                 return CreateSceneAction(
-                  entityId: task.deviceId,
+                  entityId: actions[index].deviceId,
-                  actionExecutor: 'device_issue',
+                  actionExecutor: 'delay',
                   executorProperty: CreateSceneExecutorProperty(
-                    functionCode: task.code,
+                    functionCode: '',
-                    functionValue: task.functionValue,
+                    functionValue: '',
-                    delaySeconds: 0,
+                    delaySeconds: task.functionValue,
                   ),
                 );
-              },
+              }
-            ),
+              if (task.code == CreateSceneEnum.smartSceneSelect.name) {
-            if (smartSceneBloc.smartSceneEnable != null)
+                return CreateSceneAction(
-              CreateSceneAction(
+                    entityId: actions[index].deviceId,
-                  entityId: smartSceneBloc.smartSceneEnable?.entityId ?? '',
+                    actionExecutor: actions[index].functionValue,
-                  actionExecutor:
+                    executorProperty: null);
-                      smartSceneBloc.smartSceneEnable?.actionExecutor ?? '',
+              }
-                  executorProperty: null)
+              return CreateSceneAction(
-          ],
+                entityId: task.deviceId,
-        );
+                actionExecutor: 'device_issue',
-        sceneBloc.add(CreateSceneWithTasksEvent(
+                executorProperty: CreateSceneExecutorProperty(
-          createSceneModel: createSceneModel,
+                  functionCode: task.code,
-          createAutomationModel: null,
+                  functionValue: task.functionValue,
-          updateScene: updateScene,
+                  delaySeconds: 0,
-          sceneId: sceneId,
+                ),
-        ));
+              );
-        Navigator.pop(context);
+            },
-      }
+          ),
+        ],
+      );
+      sceneBloc.add(CreateSceneWithTasksEvent(
+        createSceneModel: createSceneModel,
+        createAutomationModel: null,
+        updateScene: updateScene,
+        sceneId: sceneId,
+      ));
     }
   }
 
@@ -202,4 +186,16 @@ mixin SceneLogicHelper {
       isAutomation: isAutomation,
     );
   }
+
+  String getTaskDescription(SceneStaticFunction taskItem) {
+    if (taskItem.code == CreateSceneEnum.smartSceneSelect.name) {
+      if (taskItem.operationName == 'automation') {
+        return 'Automation: ';
+      } else {
+        return 'Tab-To-Run: ';
+      }
+    } else {
+      return "${taskItem.operationName}: ";
+    }
+  }
 }

lib/features/scene/helper/scene_operations_data_helper.dart

@@ -1,5 +1,6 @@
 import 'package:syncrow_app/features/devices/model/function_model.dart';
 import 'package:syncrow_app/features/scene/enum/ac_values.dart';
+import 'package:syncrow_app/features/scene/enum/create_scene_enum.dart';
 import 'package:syncrow_app/features/scene/enum/operation_dialog_type.dart';
 import 'package:syncrow_app/features/scene/helper/functions_per_device/ac_functions.dart';
 import 'package:syncrow_app/features/scene/helper/functions_per_device/door_lock_functions.dart';
@@ -171,13 +172,43 @@ mixin SceneOperationsDataHelper {
             icon: Assets.delay,
             operationName: 'delay',
             operationDialogType: OperationDialogType.delay,
-            functionValue: action.executorProperty.delaySeconds,
+            functionValue: action.executorProperty?.delaySeconds,
             code: '',
             operationalValues: [
               SceneOperationalValue(
                 icon: '',
                 description: "",
-                value: action.executorProperty.delaySeconds,
+                value: action.executorProperty?.delaySeconds,
+              ),
+            ],
+          ),
+        );
+      } else if (action.name != null && action.type != null) {
+        // Handle smart scenes
+        functions.add(
+          SceneStaticFunction(
+            deviceId: action.entityId,
+            deviceName: action.name.toString(),
+            deviceIcon: action.type == 'automation'
+                ? Assets.player
+                : Assets.handClickIcon,
+            icon: action.type == 'automation'
+                ? Assets.player
+                : Assets.handClickIcon,
+            operationName: action.type.toString(),
+            operationDialogType: OperationDialogType.onOff,
+            functionValue: action.actionExecutor,
+            code: CreateSceneEnum.smartSceneSelect.name,
+            operationalValues: [
+              SceneOperationalValue(
+                icon: Assets.assetsAcPower,
+                description: "Enable",
+                value: 'rule_enable',
+              ),
+              SceneOperationalValue(
+                icon: Assets.assetsAcPowerOFF,
+                description: "Disable",
+                value: 'rule_disable',
               ),
             ],
           ),
@@ -260,7 +291,7 @@ mixin SceneOperationsDataHelper {
       'factory_reset': _createFactoryResetFunction,
     };
 
-    final functionCode = executorProperty.functionCode ?? '';
+    final functionCode = executorProperty?.functionCode ?? '';
     final createFunction = functionMap[functionCode];
     if (createFunction != null) {
       return createFunction(action, isAutomation, comparator);
@@ -279,7 +310,7 @@ mixin SceneOperationsDataHelper {
     bool isAutomation, [
     String? comparator,
   ]) {
-    final functionValue = action.executorProperty.functionValue;
+    final functionValue = action.executorProperty?.functionValue;
     return SceneStaticFunction(
       deviceId: action.entityId,
       deviceName: deviceName,
@@ -287,7 +318,7 @@ mixin SceneOperationsDataHelper {
       icon: icon,
       operationName: operationName,
       functionValue: functionValue,
-      code: action.executorProperty.functionCode ?? '',
+      code: action.executorProperty?.functionCode ?? '',
       operationDialogType: operationDialogType,
       operationalValues: operationalValues,
       comparator: comparator ?? '==',
@@ -1168,7 +1199,36 @@ mixin SceneOperationsDataHelper {
         ),
       ];
     }
-
+    if (taskItem.code == CreateSceneEnum.smartSceneSelect.name) {
+      return [
+        SceneStaticFunction(
+          deviceId: taskItem.deviceId,
+          deviceName: taskItem.deviceName.toString(),
+          deviceIcon: taskItem.operationName == 'automation'
+              ? Assets.player
+              : Assets.handClickIcon,
+          icon: taskItem.operationName == 'automation'
+              ? Assets.player
+              : Assets.handClickIcon,
+          operationName: taskItem.operationName,
+          operationDialogType: OperationDialogType.onOff,
+          functionValue: taskItem.functionValue == 'rule_enable' ? true : false,
+          code: CreateSceneEnum.smartSceneSelect.name,
+          operationalValues: [
+            SceneOperationalValue(
+              icon: Assets.assetsAcPower,
+              description: "Enable",
+              value: 'rule_enable',
+            ),
+            SceneOperationalValue(
+              icon: Assets.assetsAcPowerOFF,
+              description: "Disable",
+              value: 'rule_disable',
+            ),
+          ],
+        ),
+      ];
+    }
     return [
       _mapExecutorPropertyToSceneFunction(
         Action(

lib/features/scene/model/create_scene_model.dart

@@ -102,12 +102,18 @@ class CreateSceneAction {
   }
 
   Map<String, dynamic> toMap() {
-    return {
+    if (executorProperty != null) {
-      'entityId': entityId,
+      return {
-      'actionExecutor': actionExecutor,
+        'entityId': entityId,
-      if (executorProperty != null)
+        'actionExecutor': actionExecutor,
         'executorProperty': executorProperty?.toMap(actionExecutor),
-    };
+      };
+    } else {
+      return {
+        'entityId': entityId,
+        'actionExecutor': actionExecutor,
+      };
+    }
   }
 
   factory CreateSceneAction.fromMap(Map<String, dynamic> map) {

lib/features/scene/model/scene_details_model.dart

@@ -65,19 +65,31 @@ class SceneDetailsModel {
 class Action {
   final String actionExecutor;
   final String entityId;
-  final ExecutorProperty executorProperty;
+  ExecutorProperty? executorProperty;
+  String? name;
+  String? type;
 
   Action({
     required this.actionExecutor,
     required this.entityId,
-    required this.executorProperty,
+    this.executorProperty,
+    this.name,
+    this.type,
   });
 
   String toRawJson() => json.encode(toJson());
 
   static Action? fromJson(Map<String, dynamic> json) {
+    if (json['name'] != null && json['type'] != null) {
+      return Action(
+        actionExecutor: json["actionExecutor"],
+        entityId: json["entityId"],
+        name: json['name'],
+        type: json['type'],
+      );
+    }
     if (json["executorProperty"] == null) {
-      return null; // Return null if executorProperty is not present
+      return null; 
     }
 
     return Action(
@@ -90,7 +102,7 @@ class Action {
   Map<String, dynamic> toJson() => {
         "actionExecutor": actionExecutor,
         "entityId": entityId,
-        "executorProperty": executorProperty.toJson(),
+        "executorProperty": executorProperty?.toJson(),
       };
 }
 

lib/features/scene/model/smart_scene_enable.dart

@@ -1,16 +1,25 @@
 class SmartSceneEnable {
   final String entityId;
   final String actionExecutor;
+  final String sceneORAutomationName;
+  final bool isAutomation;
+  final String type;
 
   SmartSceneEnable({
     required this.entityId,
     required this.actionExecutor,
+    required this.sceneORAutomationName,
+    required this.isAutomation,
+    required this.type,
   });
 
   factory SmartSceneEnable.fromJson(Map<String, dynamic> json) {
     return SmartSceneEnable(
       entityId: json['entityId'],
       actionExecutor: json['actionExecutor'],
+      sceneORAutomationName: json['sceneORAutomationName'],
+      isAutomation: json['isAutomation'],
+      type: json['type'],
     );
   }
 
@@ -18,6 +27,9 @@ class SmartSceneEnable {
     return {
       'entityId': entityId,
       'actionExecutor': actionExecutor,
+      'sceneORAutomationName': sceneORAutomationName,
+      'isAutomation': isAutomation,
+      'type': type,
     };
   }
 }

lib/features/scene/view/device_functions_view.dart

@@ -24,17 +24,12 @@ class DeviceFunctionsView extends StatelessWidget
 
   @override
   Widget build(BuildContext context) {
-    /// this whole widget needs a refactor later
-    ///
-    /// static functions based on type
     final device = (ModalRoute.of(context)?.settings.arguments as Map)['device']
         as DeviceModel;
 
     final isAutomation = (ModalRoute.of(context)?.settings.arguments
         as Map)['isAutomationDeviceStatus'] as bool;
 
-    /// static custom functions based on type
-    /// used for now until later backend fixes
     List<SceneStaticFunction> functions = [];
     if (device.functions.isNotEmpty) {
       functions = getFunctionsWithIcons(
@@ -47,128 +42,133 @@ class DeviceFunctionsView extends StatelessWidget
     }
 
     return DefaultScaffold(
-        title: getTitle(type: device.productType),
+      title: getTitle(type: device.productType),
-        actions: [
+      actions: [
-          TextButton(
+        TextButton(
-            onPressed: () {
-              context
-                  .read<CreateSceneBloc>()
-                  .add(AddTaskEvent(isAutomation: isAutomation));
-              navigateToRoute(context, Routes.sceneTasksRoute);
-            },
-            child: BodyMedium(
-              text: 'Save',
-              fontWeight: FontWeight.normal,
-              fontColor: ColorsManager.secondaryColor.withOpacity(0.6),
-            ),
-          ),
-        ],
-        leading: TextButton(
           onPressed: () {
-            final automationSelectedValue =
+            context
-                context.read<CreateSceneBloc>().automationSelectedValues;
+                .read<CreateSceneBloc>()
-            for (var element in device.functions) {
+                .add(AddTaskEvent(isAutomation: isAutomation));
-              if (automationSelectedValue.containsKey(element.code)) {
+            navigateToRoute(context, Routes.sceneTasksRoute);
-                context.read<CreateSceneBloc>().add(RemoveTempTaskByIdEvent(
-                    code: element.code!, isAutomation: true));
-                context.read<CreateSceneBloc>().add(RemoveFromSelectedValueById(
-                    code: element.code!, isAutomation: true));
-              }
-            }
-            final selectedValue =
-                context.read<CreateSceneBloc>().selectedValues;
-            for (var element in device.functions) {
-              if (selectedValue.containsKey(element.code)) {
-                context
-                    .read<CreateSceneBloc>()
-                    .add(RemoveTempTaskByIdEvent(code: element.code!));
-                context
-                    .read<CreateSceneBloc>()
-                    .add(RemoveFromSelectedValueById(code: element.code!));
-              }
-            }
-
-            Navigator.pop(context);
           },
           child: BodyMedium(
-            text: 'Cancel',
+            text: 'Save',
             fontWeight: FontWeight.normal,
-            fontColor: ColorsManager.textPrimaryColor.withOpacity(0.6),
+            fontColor: ColorsManager.secondaryColor.withOpacity(0.6),
           ),
         ),
-        leadingWidth: 80,
+      ],
-        padding: EdgeInsets.zero,
+      leading: TextButton(
-        child: ListView.builder(
+        onPressed: () {
-          shrinkWrap: true,
+          _cancelOperation(context, device, isAutomation);
-          itemCount: functions.length,
+        },
-          padding: const EdgeInsets.only(top: 24.0),
+        child: BodyMedium(
-          itemBuilder: (context, index) {
+          text: 'Cancel',
-            return DefaultContainer(
+          fontWeight: FontWeight.normal,
-              padding: index == 0
+          fontColor: ColorsManager.textPrimaryColor.withOpacity(0.6),
-                  ? const EdgeInsets.only(top: 8)
+        ),
-                  : index == functions.length - 1
+      ),
-                      ? const EdgeInsets.only(bottom: 8)
+      leadingWidth: 80,
-                      : EdgeInsets.zero,
+      padding: EdgeInsets.zero,
-              margin: EdgeInsets.zero,
+      child: ListView.builder(
-              borderRadius: index == 0
+        shrinkWrap: true,
-                  ? const BorderRadius.only(
+        itemCount: functions.length,
-                      topLeft: Radius.circular(20),
+        padding: const EdgeInsets.only(top: 24.0),
-                      topRight: Radius.circular(20))
+        itemBuilder: (context, index) {
-                  : index == functions.length - 1
+          return DefaultContainer(
-                      ? const BorderRadius.only(
+            padding: index == 0
-                          bottomLeft: Radius.circular(20),
+                ? const EdgeInsets.only(top: 8)
-                          bottomRight: Radius.circular(20))
+                : index == functions.length - 1
-                      : BorderRadius.zero,
+                    ? const EdgeInsets.only(bottom: 8)
-              child: Column(
+                    : EdgeInsets.zero,
-                mainAxisSize: MainAxisSize.min,
+            margin: EdgeInsets.zero,
-                children: [
+            borderRadius: index == 0
-                  BlocBuilder<CreateSceneBloc, CreateSceneState>(
+                ? const BorderRadius.only(
-                    builder: (context, state) {
+                    topLeft: Radius.circular(20), topRight: Radius.circular(20))
-                      return SceneListTile(
+                : index == functions.length - 1
-                        iconsSize: 22,
+                    ? const BorderRadius.only(
-                        minLeadingWidth: 20,
+                        bottomLeft: Radius.circular(20),
-                        assetPath: functions[index].icon,
+                        bottomRight: Radius.circular(20))
-                        titleString: functions[index].operationName,
+                    : BorderRadius.zero,
-                        trailingWidget: const Row(
+            child: Column(
-                          mainAxisSize: MainAxisSize.min,
+              mainAxisSize: MainAxisSize.min,
-                          children: [
+              children: [
-                            /// selected value or the default value
+                BlocBuilder<CreateSceneBloc, CreateSceneState>(
-                            // BodyMedium(text: ),
+                  builder: (context, state) {
-                            Icon(
+                    return SceneListTile(
-                              Icons.arrow_forward_ios_rounded,
+                      iconsSize: 22,
-                              color: ColorsManager.greyColor,
+                      minLeadingWidth: 20,
-                              size: 16,
+                      assetPath: functions[index].icon,
-                            ),
+                      titleString: functions[index].operationName,
-                          ],
+                      trailingWidget: const Row(
-                        ),
+                        mainAxisSize: MainAxisSize.min,
-                        onPressed: () {
+                        children: [
-                          if (isAutomation) {
+                          Icon(
-                            _showAutomationDialog(
+                            Icons.arrow_forward_ios_rounded,
-                              context,
+                            color: ColorsManager.greyColor,
-                              functions[index],
+                            size: 16,
-                              device,
+                          ),
-                            );
+                        ],
-                          } else {
+                      ),
-                            _showTabToRunDialog(
+                      onPressed: () {
-                              context,
+                        if (isAutomation) {
-                              functions[index],
+                          _showAutomationDialog(
-                              device,
+                            context,
-                            );
+                            functions[index],
-                          }
+                            device,
-                        },
+                          );
-                      );
+                        } else {
-                    },
+                          _showTabToRunDialog(
-                  ),
+                            context,
-                  index != functions.length - 1
+                            functions[index],
-                      ? SizedBox(
+                            device,
-                          width: context.width * 0.8,
+                          );
-                          child: const LightDivider())
+                        }
-                      : const SizedBox(),
+                      },
-                ],
+                    );
-              ),
+                  },
-            );
+                ),
-          },
+                index != functions.length - 1
-        ));
+                    ? SizedBox(
+                        width: context.width * 0.8, child: const LightDivider())
+                    : const SizedBox(),
+              ],
+            ),
+          );
+        },
+      ),
+    );
+  }
+
+  void _cancelOperation(
+      BuildContext context, DeviceModel device, bool isAutomation) {
+    final createSceneBloc = context.read<CreateSceneBloc>();
+    final automationSelectedValue = createSceneBloc.automationSelectedValues;
+    if (automationSelectedValue.isNotEmpty) {
+      for (var element in device.functions) {
+        if (automationSelectedValue.containsKey(element.code)) {
+          createSceneBloc.add(
+              RemoveTempTaskByIdEvent(code: element.code!, isAutomation: true));
+          createSceneBloc.add(RemoveFromSelectedValueById(
+              code: element.code!, isAutomation: true));
+        }
+      }
+    }
+
+    final selectedValue = createSceneBloc.selectedValues;
+    if (selectedValue.isNotEmpty) {
+      for (var element in device.functions) {
+        if (selectedValue.containsKey(element.code)) {
+          createSceneBloc.add(RemoveTempTaskByIdEvent(code: element.code!));
+          createSceneBloc.add(RemoveFromSelectedValueById(code: element.code!));
+        }
+      }
+    }
+
+    Navigator.pop(context);
+
+    createSceneBloc.add(const ClearTempTaskListEvent(isAutomation: false));
+    createSceneBloc.add(const ClearTempTaskListEvent(isAutomation: true));
   }
 
   void _showTabToRunDialog(

lib/features/scene/view/scene_auto_settings.dart

@@ -1,9 +1,12 @@
 import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:syncrow_app/features/scene/bloc/create_scene/create_scene_bloc.dart';
+import 'package:syncrow_app/features/scene/enum/create_scene_enum.dart';
 import 'package:syncrow_app/features/scene/view/scene_tasks_view.dart';
 import 'package:syncrow_app/features/scene/widgets/effective_period_setting/effective_period_bottom_sheet.dart';
 import 'package:syncrow_app/features/scene/widgets/scene_list_tile.dart';
-import 'package:syncrow_app/features/shared_widgets/default_container.dart';
 import 'package:syncrow_app/features/shared_widgets/text_widgets/body_large.dart';
+import 'package:syncrow_app/generated/assets.dart';
 import 'package:syncrow_app/utils/context_extension.dart';
 import 'package:syncrow_app/utils/resource_manager/color_manager.dart';
 import 'package:syncrow_app/utils/resource_manager/font_manager.dart';
@@ -17,7 +20,8 @@ class SceneAutoSettings extends StatelessWidget {
         ModalRoute.of(context)!.settings.arguments as Map<String, dynamic>? ??
             {};
     final sceneId = sceneSettings['sceneId'] as String? ?? '';
-    final isAutomation = sceneSettings['isAutomation'] as bool? ?? false;
+    final isAutomation = context.read<CreateSceneBloc>().sceneType ==
+        CreateSceneEnum.deviceStatusChanges;
     final sceneName = sceneSettings['sceneName'] as String? ?? '';
 
     return Scaffold(
@@ -31,35 +35,79 @@ class SceneAutoSettings extends StatelessWidget {
           fontWeight: FontsManager.bold,
         ),
       ),
-      body: DefaultContainer(
+      body: Stack(
-        padding: EdgeInsets.zero,
+        children: [
-        child: Column(
+          Container(
-          mainAxisSize: MainAxisSize.min,
+            width: double.infinity,
-          mainAxisAlignment: MainAxisAlignment.center,
+            height: context.height,
-          children: [
+            decoration: const BoxDecoration(
-            Visibility(
+              color: ColorsManager.backgroundColor,
-              visible: isAutomation == true,
+              image: DecorationImage(
-              child: SceneListTile(
+                image: AssetImage(
-                padding:
+                  Assets.assetsImagesBackground,
-                    const EdgeInsets.symmetric(horizontal: 16, vertical: 8),
+                ),
-                titleString: "Effective Period",
+                fit: BoxFit.cover,
-                trailingWidget: const Icon(Icons.arrow_forward_ios_rounded),
+                opacity: 0.4,
-                onPressed: () {
-                  context.customBottomSheet(
-                    child: const EffectPeriodBottomSheetContent(),
-                  );
-                },
               ),
             ),
-            Visibility(
+          ),
-              visible: sceneName.isNotEmpty,
+          Padding(
-              child: DeleteBottomSheetContent(
+            padding: const EdgeInsets.symmetric(vertical: 16),
-                isAutomation: isAutomation,
+            child: Container(
-                sceneId: sceneId,
+              decoration: const BoxDecoration(
+                color: Colors.white,
+                borderRadius: BorderRadius.all(Radius.circular(16)),
+              ),
+              constraints: const BoxConstraints(
+                maxWidth: 600,
+                maxHeight: 300,
+              ),
+              child: Column(
+                mainAxisSize: MainAxisSize.min,
+                mainAxisAlignment: MainAxisAlignment.start,
+                children: [
+                  const SizedBox(
+                    height: 8,
+                  ),
+                  Visibility(
+                    visible: isAutomation == true,
+                    child: SceneListTile(
+                      padding: const EdgeInsets.symmetric(
+                          horizontal: 16, vertical: 8),
+                      titleString: "Effective Period",
+                      trailingWidget:
+                          const Icon(Icons.arrow_forward_ios_rounded),
+                      onPressed: () {
+                        context.customBottomSheet(
+                          child: const EffectPeriodBottomSheetContent(),
+                        );
+                      },
+                    ),
+                  ),
+                  Visibility(
+                    visible: sceneName.isNotEmpty,
+                    child: SizedBox(
+                      width: context.width * 0.9,
+                      child: const Divider(
+                        color: ColorsManager.greyColor,
+                      ),
+                    ),
+                  ),
+                  Visibility(
+                    visible: sceneName.isNotEmpty,
+                    child: DeleteBottomSheetContent(
+                      isAutomation: isAutomation,
+                      sceneId: sceneId,
+                    ),
+                  ),
+                  const SizedBox(
+                    height: 16,
+                  ),
+                ],
               ),
             ),
-          ],
+          ),
-        ),
+        ],
       ),
     );
   }

lib/features/scene/view/scene_tasks_view.dart

@@ -11,7 +11,6 @@ import 'package:syncrow_app/features/scene/widgets/create_scene_save_button.dart
 import 'package:syncrow_app/features/scene/widgets/if_then_containers/if_container.dart';
 import 'package:syncrow_app/features/scene/widgets/if_then_containers/then_container.dart';
 import 'package:syncrow_app/features/scene/widgets/scene_list_tile.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/generated/assets.dart';
 import 'package:syncrow_app/navigation/navigate_to_route.dart';
@@ -36,32 +35,44 @@ class SceneTasksView extends StatelessWidget {
           ? sceneSettings.sceneName
           : StringsManager.createScene,
       padding: EdgeInsets.zero,
+      leading: IconButton(
+          onPressed: () {
+            navigateToRoute(context, Routes.homeRoute);
+          },
+          icon: const Icon(
+            Icons.arrow_back_ios,
+          )),
       actions: [
-        Visibility(
+        BlocBuilder<CreateSceneBloc, CreateSceneState>(
-          visible: sceneSettings.sceneType.isNotEmpty,
+          builder: (context, state) {
-          child: SizedBox(
+            final sceneType = context.read<CreateSceneBloc>().sceneType;
-            width: 40,
+            return Visibility(
-            child: GestureDetector(
+              visible: sceneType != CreateSceneEnum.none,
-              onTap: () {
+              child: SizedBox(
-                Navigator.pushNamed(
+                width: 40,
-                  context,
+                child: GestureDetector(
-                  Routes.sceneAutoSettingsRoute,
+                  onTap: () {
-                  arguments: {
+                    Navigator.pushNamed(
-                    "sceneId": sceneSettings.sceneId,
+                      context,
-                    "isAutomation": isAutomation,
+                      Routes.sceneAutoSettingsRoute,
-                    "sceneName": sceneSettings.sceneName,
+                      arguments: {
+                        "sceneId": sceneSettings.sceneId,
+                        "isAutomation": isAutomation,
+                        "sceneName": sceneSettings.sceneName,
+                      },
+                    );
                   },
-                );
+                  child: SvgPicture.asset(
-              },
+                    Assets.assetsIconsSettings,
-              child: SvgPicture.asset(
+                    colorFilter: const ColorFilter.mode(
-                Assets.assetsIconsSettings,
+                      ColorsManager.textPrimaryColor,
-                colorFilter: const ColorFilter.mode(
+                      BlendMode.srcIn,
-                  ColorsManager.textPrimaryColor,
+                    ),
-                  BlendMode.srcIn,
+                  ),
                 ),
               ),
-            ),
+            );
-          ),
+          },
         ),
       ],
       child: Stack(
@@ -113,44 +124,39 @@ class DeleteBottomSheetContent extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    return DefaultContainer(
+    return BlocConsumer<CreateSceneBloc, CreateSceneState>(
-        padding: EdgeInsets.zero,
+      listener: (context, state) {
-        child: BlocConsumer<CreateSceneBloc, CreateSceneState>(
+        if (state is DeleteSceneSuccess) {
-          listener: (context, state) {
+          if (state.success) {
-            if (state is DeleteSceneSuccess) {
+            navigateToRoute(context, Routes.homeRoute);
-              if (state.success) {
+            BlocProvider.of<SceneBloc>(context)
-                navigateToRoute(context, Routes.homeRoute);
+                .add(LoadScenes(HomeCubit.getInstance().selectedSpace!.id!));
-                BlocProvider.of<SceneBloc>(context).add(
+            BlocProvider.of<SceneBloc>(context).add(
-                    LoadScenes(HomeCubit.getInstance().selectedSpace!.id!));
+                LoadAutomation(HomeCubit.getInstance().selectedSpace!.id!));
-                BlocProvider.of<SceneBloc>(context).add(
+          }
-                    LoadAutomation(HomeCubit.getInstance().selectedSpace!.id!));
+        }
-              }
+      },
-            }
+      builder: (context, state) {
-          },
+        return SceneListTile(
-          builder: (context, state) {
+          onPressed: () {
-            return DefaultContainer(
+            context.read<CreateSceneBloc>().add(DeleteSceneEvent(
-                onTap: () {
+                  sceneId: sceneId,
-                  context.read<CreateSceneBloc>().add(DeleteSceneEvent(
+                  unitUuid: HomeCubit.getInstance().selectedSpace!.id!,
-                        sceneId: sceneId,
-                        unitUuid: HomeCubit.getInstance().selectedSpace!.id!,
-                      ));
-                },
-                child: SceneListTile(
-                  padding: const EdgeInsets.symmetric(horizontal: 8),
-                  titleString: isAutomation
-                      ? StringsManager.deleteAutomation
-                      : StringsManager.deleteScene,
-                  leadingWidget: (state is DeleteSceneLoading)
-                      ? const SizedBox(
-                          height: 24,
-                          width: 24,
-                          child: CircularProgressIndicator())
-                      : SvgPicture.asset(
-                          Assets.assetsDeleteIcon,
-                          color: ColorsManager.red,
-                        ),
                 ));
           },
-        ));
+          padding: const EdgeInsets.symmetric(horizontal: 8),
+          titleString: isAutomation
+              ? StringsManager.deleteAutomation
+              : StringsManager.deleteScene,
+          leadingWidget: (state is DeleteSceneLoading)
+              ? const SizedBox(
+                  height: 24, width: 24, child: CircularProgressIndicator())
+              : SvgPicture.asset(
+                  Assets.assetsDeleteIcon,
+                  color: ColorsManager.red,
+                ),
+        );
+      },
+    );
   }
 }

lib/features/scene/view/smart_automation_select_route.dart

@@ -1,4 +1,7 @@
 import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:syncrow_app/features/scene/bloc/create_scene/create_scene_bloc.dart';
+import 'package:syncrow_app/features/scene/enum/create_scene_enum.dart';
 import 'package:syncrow_app/features/scene/widgets/scene_list_tile.dart';
 import 'package:syncrow_app/features/scene/widgets/select_smart_scene/smart_enable_autoamtion.dart';
 import 'package:syncrow_app/features/scene/widgets/select_smart_scene/smart_enable_tab_run.dart';
@@ -15,6 +18,7 @@ class SmartAutomationSelectView extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
+    final sceneType = context.read<CreateSceneBloc>().sceneType;
     return DefaultScaffold(
       title: "Select Smart Scene",
       padding: const EdgeInsets.only(top: 24),
@@ -25,28 +29,38 @@ class SmartAutomationSelectView extends StatelessWidget {
           icon: const Icon(
             Icons.arrow_back_ios,
           )),
-      height: 260,
+      height: sceneType.name == CreateSceneEnum.deviceStatusChanges.name
+          ? 260
+          : 200,
       child: DefaultContainer(
         width: double.infinity,
         child: Column(
           mainAxisAlignment: MainAxisAlignment.center,
           children: [
-            SceneListTile(
+            Visibility(
-              assetPath: Assets.handClickIcon,
+              visible:
-              titleString: "Tap To Run",
+                  sceneType.name == CreateSceneEnum.deviceStatusChanges.name,
-              subtitleString: '',
+              child: SceneListTile(
-              trailingWidget: const Icon(
+                assetPath: Assets.handClickIcon,
-                Icons.arrow_forward_ios_rounded,
+                titleString: "Tap To Run",
-                color: ColorsManager.greyColor,
+                subtitleString: '',
+                trailingWidget: const Icon(
+                  Icons.arrow_forward_ios_rounded,
+                  color: ColorsManager.greyColor,
+                ),
+                onPressed: () {
+                  context.customBottomSheet(
+                    child: const SmartEnableTabRun(),
+                  );
+                },
               ),
-              onPressed: () {
-                context.customBottomSheet(
-                  child: const SmartEnableTabRun(),
-                );
-              },
             ),
-            const Divider(
+            Visibility(
-              color: ColorsManager.dividerColor,
+              visible:
+                  sceneType.name == CreateSceneEnum.deviceStatusChanges.name,
+              child: const Divider(
+                color: ColorsManager.dividerColor,
+              ),
             ),
             SceneListTile(
               assetPath: Assets.refreshIcon,

lib/features/scene/widgets/create_scene_save_button.dart

@@ -8,6 +8,7 @@ import 'package:syncrow_app/features/shared_widgets/text_widgets/body_large.dart
 import 'package:syncrow_app/navigation/navigate_to_route.dart';
 import 'package:syncrow_app/navigation/routing_constants.dart';
 import 'package:syncrow_app/utils/context_extension.dart';
+import 'package:syncrow_app/utils/helpers/snack_bar.dart';
 import 'package:syncrow_app/utils/resource_manager/color_manager.dart';
 
 class CreateSceneSaveButton extends StatefulWidget {
@@ -57,13 +58,7 @@ class _CreateSceneSaveButtonState extends State<CreateSceneSaveButton>
             sceneNameController.text = '';
           }
         } else if (state is CreateSceneError) {
-          context.showCustomSnackbar(
+          CustomSnackBar.displaySnackBar(state.message);
-            message: state.message,
-            icon: const Icon(
-              Icons.error,
-              color: Colors.red,
-            ),
-          );
         }
       },
       builder: (context, state) {
@@ -106,6 +101,7 @@ class _CreateSceneSaveButtonState extends State<CreateSceneSaveButton>
                 ),
                 title: 'Scene Name',
                 onConfirm: () {
+                  Navigator.pop(context);
                   if (sceneNameController.text.isNotEmpty) {
                     handleSaveButtonPress(
                       context,

lib/features/scene/widgets/effective_period_setting/period_options.dart

@@ -39,11 +39,11 @@ class PeriodOptions extends StatelessWidget {
                   state.customStartTime != null && state.customEndTime != null
                       ? BodySmall(
                           text:
-                              '${"${state.customStartTime} AM"} - ${"${state.customEndTime} PM"}',
+                              '${"${state.customStartTime}"} - ${"${state.customEndTime}"}',
                           style: context.bodySmall.copyWith(fontSize: 10),
                         )
                       : BodySmall(
-                          text: '00:00 AM - 11:59 PM',
+                          text: '00:00 - 23:59',
                           style: context.bodySmall.copyWith(fontSize: 10),
                         ),
               trailing: Radio<EnumEffectivePeriodOptions>(

lib/features/scene/widgets/if_then_containers/if_container.dart

@@ -27,94 +27,164 @@ class IFDefaultContainer extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
-    final sceneType = context.read<CreateSceneBloc>().sceneType;
+    return BlocBuilder<CreateSceneBloc, CreateSceneState>(
-    return DefaultContainer(
+      builder: (context, state) {
-      padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 2),
+        final sceneType = context.read<CreateSceneBloc>().sceneType;
-      child: Column(
+        return DefaultContainer(
-        mainAxisSize: MainAxisSize.min,
+          padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 2),
-        children: [
+          child: Column(
-          SceneListTile(
+            mainAxisSize: MainAxisSize.min,
-            leadingWidget: InkWell(
+            children: [
-              onTap: () {
+              SceneListTile(
-                if (sceneType.name ==
+                leadingWidget: InkWell(
-                    CreateSceneEnum.deviceStatusChanges.name) {
+                  onTap: () {
-                  context.customAlertDialog(
+                    if (sceneType.name ==
-                    hideConfirmButton: true,
+                        CreateSceneEnum.deviceStatusChanges.name) {
-                    alertBody: Column(
+                      context.customAlertDialog(
-                      children: [
+                        hideConfirmButton: true,
-                        ListTile(
+                        alertBody: Column(
-                          title: const BodyMedium(
+                          children: [
-                              text: "When all conditions are met"),
+                            ListTile(
-                          onTap: () {
+                              title: const BodyMedium(
-                            context.read<CreateSceneBloc>().add(
+                                  text: "When all conditions are met"),
-                                const SelectConditionEvent(
+                              onTap: () {
-                                    "When all conditions are met"));
+                                context.read<CreateSceneBloc>().add(
-                            Navigator.pop(context);
+                                    const SelectConditionEvent(
+                                        "When all conditions are met"));
+                                Navigator.pop(context);
+                              },
+                            ),
+                            ListTile(
+                              title: const BodyMedium(
+                                  text: "When any condition is met"),
+                              onTap: () {
+                                context.read<CreateSceneBloc>().add(
+                                    const SelectConditionEvent(
+                                        "When any condition is met"));
+                                Navigator.pop(context);
+                              },
+                            ),
+                          ],
+                        ),
+                        title: 'Conditions Rule',
+                        onConfirm: () {},
+                      );
+                    }
+                  },
+                  child: Column(
+                    crossAxisAlignment: CrossAxisAlignment.start,
+                    mainAxisAlignment: MainAxisAlignment.end,
+                    children: [
+                      BodyLarge(
+                        text: 'IF',
+                        style: context.bodyLarge.copyWith(
+                          fontWeight: FontWeight.bold,
+                          color: ColorsManager.primaryTextColor,
+                        ),
+                      ),
+                      Visibility(
+                        visible: sceneType.name ==
+                            CreateSceneEnum.deviceStatusChanges.name,
+                        child: BlocBuilder<CreateSceneBloc, CreateSceneState>(
+                          builder: (context, state) {
+                            String conditionText = "When any condition is met";
+                            if (state is AddSceneTask) {
+                              if (state.condition == 'or') {
+                                conditionText = "When any condition is met";
+                              } else {
+                                conditionText = "When all conditions are met";
+                              }
+                            }
+                            return SizedBox(
+                              width: context.width * 0.6,
+                              child: Row(children: [
+                                BodySmall(text: conditionText),
+                                const Icon(Icons.keyboard_arrow_down)
+                              ]),
+                            );
                           },
                         ),
-                        ListTile(
+                      ),
-                          title: const BodyMedium(
+                    ],
-                              text: "When any condition is met"),
+                  ),
-                          onTap: () {
+                ),
-                            context.read<CreateSceneBloc>().add(
+                trailingWidget: BlocBuilder<CreateSceneBloc, CreateSceneState>(
-                                const SelectConditionEvent(
+                  builder: (context, state) {
-                                    "When any condition is met"));
+                    bool isClickable = false;
-                            Navigator.pop(context);
+                    if (state is AddSceneTask) {
-                          },
+                      isClickable =
+                          state.automationTasksList?.isNotEmpty ?? false;
+                    }
+                    return GestureDetector(
+                      onTap: isClickable
+                          ? () => Navigator.pushNamed(
+                                context,
+                                Routes.sceneControlDevicesRoute,
+                                arguments: SceneSettingsRouteArguments(
+                                  sceneType:
+                                      CreateSceneEnum.deviceStatusChanges.name,
+                                  sceneId: '',
+                                  sceneName: '',
+                                ),
+                              )
+                          : null,
+                      child: SvgPicture.asset(
+                        Assets.addIcon,
+                        colorFilter: ColorFilter.mode(
+                          isClickable
+                              ? ColorsManager.primaryColor
+                              : ColorsManager.greyColor,
+                          BlendMode.srcIn,
                         ),
-                      ],
+                      ),
-                    ),
+                    );
-                    title: 'Conditions Rule',
+                  },
-                    onConfirm: () {},
+                ),
-                  );
+                padding: EdgeInsets.zero,
-                }
-              },
-              child: Column(
-                crossAxisAlignment: CrossAxisAlignment.start,
-                mainAxisAlignment: MainAxisAlignment.end,
-                children: [
-                  BodyLarge(
-                    text: 'IF',
-                    style: context.bodyLarge.copyWith(
-                      fontWeight: FontWeight.bold,
-                      color: ColorsManager.primaryTextColor,
-                    ),
-                  ),
-                  Visibility(
-                    visible: sceneType.name ==
-                        CreateSceneEnum.deviceStatusChanges.name,
-                    child: BlocBuilder<CreateSceneBloc, CreateSceneState>(
-                      builder: (context, state) {
-                        String conditionText = "When any condition is met";
-                        if (state is AddSceneTask) {
-                          if (state.condition == 'or') {
-                            conditionText = "When any condition is met";
-                          } else {
-                            conditionText = "When all conditions are met";
-                          }
-                        }
-                        return SizedBox(
-                          width: context.width * 0.6,
-                          child: Row(children: [
-                            BodySmall(text: conditionText),
-                            const Icon(Icons.keyboard_arrow_down)
-                          ]),
-                        );
-                      },
-                    ),
-                  ),
-                ],
               ),
-            ),
+              const LightDivider(),
-            trailingWidget: BlocBuilder<CreateSceneBloc, CreateSceneState>(
+              BlocBuilder<CreateSceneBloc, CreateSceneState>(
-              builder: (context, state) {
+                builder: (context, state) {
-                bool isClickable = false;
+                  if (state is AddSceneTask) {
-                if (state is AddSceneTask) {
+                    final automationTasksList = state.automationTasksList;
-                  isClickable = state.automationTasksList?.isNotEmpty ?? false;
+                    if (automationTasksList?.isNotEmpty == true) {
-                }
+                      return ListView.builder(
-                return GestureDetector(
+                        shrinkWrap: true,
-                  onTap: isClickable
+                        physics: const NeverScrollableScrollPhysics(),
-                      ? () => Navigator.pushNamed(
+                        itemCount: automationTasksList?.length,
+                        reverse: true,
+                        itemBuilder: (context, index) {
+                          return ThenAddedTasksContainer(
+                            taskItem: automationTasksList![index],
+                            isAutomation: true,
+                          );
+                        },
+                      );
+                    }
+                  }
+                  final sceneType = context.read<CreateSceneBloc>().sceneType;
+                  if (sceneType.name == CreateSceneEnum.tabToRun.name) {
+                    return const SceneListTile(
+                      padding: EdgeInsets.symmetric(horizontal: 2),
+                      assetPath: Assets.handClickIcon,
+                      titleString: StringsManager.tapToRun,
+                      subtitleString: '',
+                    );
+                  }
+                  return SceneListTile(
+                      titleString: '+ Add Condition',
+                      textAlign: TextAlign.center,
+                      onPressed: () {
+                        final sceneType =
+                            context.read<CreateSceneBloc>().sceneType;
+                        if (sceneType.name == CreateSceneEnum.none.name) {
+                          Navigator.push(
+                              context,
+                              CustomPageRoute(
+                                  builder: (context) =>
+                                      const CreateSceneView()));
+                        } else {
+                          Navigator.pushNamed(
                             context,
                             Routes.sceneControlDevicesRoute,
                             arguments: SceneSettingsRouteArguments(
@@ -123,77 +193,15 @@ class IFDefaultContainer extends StatelessWidget {
                               sceneId: '',
                               sceneName: '',
                             ),
-                          )
+                          );
-                      : null,
+                        }
-                  child: SvgPicture.asset(
+                      });
-                    Assets.addIcon,
+                },
-                    colorFilter: ColorFilter.mode(
+              )
-                      isClickable
+            ],
-                          ? ColorsManager.primaryColor
-                          : ColorsManager.greyColor,
-                      BlendMode.srcIn,
-                    ),
-                  ),
-                );
-              },
-            ),
-            padding: EdgeInsets.zero,
           ),
-          const LightDivider(),
+        );
-          BlocBuilder<CreateSceneBloc, CreateSceneState>(
+      },
-            builder: (context, state) {
-              if (state is AddSceneTask) {
-                final automationTasksList = state.automationTasksList;
-                if (automationTasksList?.isNotEmpty == true) {
-                  return ListView.builder(
-                    shrinkWrap: true,
-                    physics: const NeverScrollableScrollPhysics(),
-                    itemCount: automationTasksList?.length,
-                    reverse: true,
-                    itemBuilder: (context, index) {
-                      return ThenAddedTasksContainer(
-                        taskItem: automationTasksList![index],
-                        isAutomation: true,
-                      );
-                    },
-                  );
-                }
-              }
-              final sceneType = context.read<CreateSceneBloc>().sceneType;
-              if (sceneType.name == CreateSceneEnum.tabToRun.name) {
-                return const SceneListTile(
-                  padding: EdgeInsets.symmetric(horizontal: 2),
-                  assetPath: Assets.handClickIcon,
-                  titleString: StringsManager.tapToRun,
-                  subtitleString: '',
-                );
-              }
-              return SceneListTile(
-                  titleString: '+ Add Condition',
-                  textAlign: TextAlign.center,
-                  onPressed: () {
-                    final sceneType = context.read<CreateSceneBloc>().sceneType;
-                    if (sceneType.name == CreateSceneEnum.none.name) {
-                      Navigator.push(
-                          context,
-                          CustomPageRoute(
-                              builder: (context) => const CreateSceneView()));
-                    } else {
-                      Navigator.pushNamed(
-                        context,
-                        Routes.sceneControlDevicesRoute,
-                        arguments: SceneSettingsRouteArguments(
-                          sceneType: CreateSceneEnum.deviceStatusChanges.name,
-                          sceneId: '',
-                          sceneName: '',
-                        ),
-                      );
-                    }
-                  });
-            },
-          )
-        ],
-      ),
     );
   }
 }

lib/features/scene/widgets/if_then_containers/then_added_tasks.dart

@@ -4,11 +4,14 @@ import 'package:flutter/material.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:flutter_svg/flutter_svg.dart';
 import 'package:syncrow_app/features/scene/bloc/create_scene/create_scene_bloc.dart';
+import 'package:syncrow_app/features/scene/bloc/smart_scene/smart_scene_select_dart_bloc.dart';
+import 'package:syncrow_app/features/scene/enum/create_scene_enum.dart';
 import 'package:syncrow_app/features/scene/helper/scene_logic_helper.dart';
 import 'package:syncrow_app/features/scene/helper/scene_operations_data_helper.dart';
 import 'package:syncrow_app/features/scene/model/scene_static_function.dart';
 
 import 'package:syncrow_app/features/scene/widgets/scene_list_tile.dart';
+import 'package:syncrow_app/features/scene/widgets/select_smart_scene/smart_automation_list.dart';
 import 'package:syncrow_app/features/shared_widgets/default_container.dart';
 import 'package:syncrow_app/features/shared_widgets/text_widgets/body_medium.dart';
 import 'package:syncrow_app/generated/assets.dart';
@@ -62,58 +65,90 @@ class ThenAddedTasksContainer extends StatelessWidget
       operationValue = functionValue.toString();
     }
     return DefaultContainer(
-      onTap: () {
+      onTap: taskItem.operationName == 'tap_to_run' ||
-        List<SceneStaticFunction> functionOperation = [];
+              taskItem.operationName == 'scene'
+          ? null
+          : () {
+              List<SceneStaticFunction> functionOperation = [];
 
-        /// get the task functions
+              /// get the task functions
-        functionOperation = List.from(getOperationsForOneFunction(
+              functionOperation = List.from(getOperationsForOneFunction(
-            taskItem: taskItem,
+                  taskItem: taskItem,
-            deviceId: taskItem.deviceId,
+                  deviceId: taskItem.deviceId,
-            isAutomation: isAutomation ?? false));
+                  isAutomation: isAutomation ?? false));
 
-        /// show alert dialog based on type
+              if (taskItem.code == CreateSceneEnum.smartSceneSelect.name) {
-        context.customAlertDialog(
+                context.customAlertDialog(
-          alertBody: getTheCorrectDialogBody(functionOperation.first, null,
+                  alertBody: EnableDisableAutomationDialog(
-              isAutomation: isAutomation ?? false),
+                    automationId: taskItem.deviceId,
-          title: functionOperation.first.operationName,
+                    descriptionSelected: taskItem.functionValue == 'rule_enable'
-          onConfirm: () {
+                        ? 'Enable'
-            final savedCode = functionOperation.first.deviceId.contains('delay')
+                        : "Disable",
-                ? 'delay'
+                    sceneORAutomationName: taskItem.deviceName,
-                : functionOperation.first.code;
+                    type: taskItem.operationName,
-            if (isAutomation == true) {
-              final automationSelectedValue =
-                  createSceneBloc.automationSelectedValues[savedCode];
-
-              try {
-                createSceneBloc.add(
-                  UpdateTaskEvent(
-                    newValue: automationSelectedValue,
-                    taskId: taskItem.uniqueCustomId,
-                    isAutomation: true,
                   ),
+                  title: taskItem.deviceName,
+                  onConfirm: () {
+                    context
+                        .read<SmartSceneSelectBloc>()
+                        .add(const SmartSceneConfirmSelectionEvent());
+                    Navigator.pop(context);
+                  },
+                  onDismiss: () {
+                    context
+                        .read<SmartSceneSelectBloc>()
+                        .add(const SmartSceneClearEvent());
+                    Navigator.pop(context);
+                  },
                 );
-              } catch (e) {
+              } else {
-                debugPrint('Error adding UpdateTaskEvent: $e');
+                /// show alert dialog based on type
-              }
+                context.customAlertDialog(
-            } else {
+                  alertBody: getTheCorrectDialogBody(
-              final selectedValue = createSceneBloc.selectedValues[savedCode];
+                      functionOperation.first, null,
+                      isAutomation: isAutomation ?? false),
+                  title: functionOperation.first.operationName,
+                  onConfirm: () {
+                    final savedCode =
+                        functionOperation.first.deviceId.contains('delay')
+                            ? 'delay'
+                            : functionOperation.first.code;
+                    if (isAutomation == true) {
+                      final automationSelectedValue =
+                          createSceneBloc.automationSelectedValues[savedCode];
 
-              try {
+                      try {
-                createSceneBloc.add(
+                        createSceneBloc.add(
-                  UpdateTaskEvent(
+                          UpdateTaskEvent(
-                    newValue: selectedValue,
+                            newValue: automationSelectedValue,
-                    taskId: taskItem.uniqueCustomId,
+                            taskId: taskItem.uniqueCustomId,
-                  ),
+                            isAutomation: true,
+                          ),
+                        );
+                      } catch (e) {
+                        debugPrint('Error adding UpdateTaskEvent: $e');
+                      }
+                    } else {
+                      final selectedValue =
+                          createSceneBloc.selectedValues[savedCode];
+
+                      try {
+                        createSceneBloc.add(
+                          UpdateTaskEvent(
+                            newValue: selectedValue,
+                            taskId: taskItem.uniqueCustomId,
+                          ),
+                        );
+                      } catch (e) {
+                        debugPrint('Error adding UpdateTaskEvent: $e');
+                      }
+                    }
+
+                    Navigator.pop(context);
+                  },
                 );
-              } catch (e) {
-                debugPrint('Error adding UpdateTaskEvent: $e');
               }
-            }
+            },
-
-            Navigator.pop(context);
-          },
-        );
-      },
       padding: EdgeInsets.zero,
       child: Dismissible(
         key: Key(taskItem.uniqueCustomId.toString()),
@@ -149,6 +184,9 @@ class ThenAddedTasksContainer extends StatelessWidget
                   taskId: removeFunctionById,
                 ));
           }
+          context
+              .read<SmartSceneSelectBloc>()
+              .add(const SmartSceneClearEvent());
 
           String removeFunction =
               "${taskItem.operationName} with value ${taskItem.operationalValues.first.value}";
@@ -171,12 +209,16 @@ class ThenAddedTasksContainer extends StatelessWidget
           subtitleWidget: Row(
             children: [
               BodyMedium(
-                text: "${taskItem.operationName}: ",
+                text: getTaskDescription(taskItem),
                 fontColor: ColorsManager.secondaryTextColor,
                 fontWeight: FontWeight.normal,
               ),
               BodyMedium(
-                text: operationValue,
+                text: taskItem.code == CreateSceneEnum.smartSceneSelect.name
+                    ? taskItem.functionValue == 'rule_enable'
+                        ? 'Enable'
+                        : "Disable"
+                    : operationValue,
                 fontColor: ColorsManager.secondaryTextColor,
                 fontWeight: FontWeight.normal,
               ),

lib/features/scene/widgets/scene_view_widget/scene_item.dart

@@ -5,6 +5,7 @@ import 'package:syncrow_app/features/app_layout/bloc/home_cubit.dart';
 import 'package:syncrow_app/features/scene/bloc/create_scene/create_scene_bloc.dart';
 import 'package:syncrow_app/features/scene/bloc/scene_bloc/scene_bloc.dart';
 import 'package:syncrow_app/features/scene/bloc/scene_bloc/scene_event.dart';
+import 'package:syncrow_app/features/scene/bloc/smart_scene/smart_scene_select_dart_bloc.dart';
 import 'package:syncrow_app/features/scene/enum/create_scene_enum.dart';
 import 'package:syncrow_app/features/scene/model/scenes_model.dart';
 import 'package:syncrow_app/features/scene/model/scene_settings_route_arguments.dart';
@@ -45,6 +46,7 @@ class SceneItem extends StatelessWidget {
             sceneName: scene.name,
           ),
         );
+        context.read<SmartSceneSelectBloc>().add(const SmartSceneClearEvent());
         if (disablePlayButton == false) {
           BlocProvider.of<CreateSceneBloc>(context)
               .add(const SceneTypeEvent(CreateSceneEnum.tabToRun));

lib/features/scene/widgets/select_smart_scene/smart_automation_list.dart

@@ -125,9 +125,14 @@ class _SmartSceneSelectAutomationListState
                           alertBody: EnableDisableAutomationDialog(
                             automationId: automation.id,
                             descriptionSelected: descriptionSelected,
+                            sceneORAutomationName: automation.name,
+                            type: automation.type,
                           ),
                           title: automation.name,
                           onConfirm: () {
+                            context
+                                .read<SmartSceneSelectBloc>()
+                                .add(const SmartSceneConfirmSelectionEvent());
                             Navigator.pop(context);
                           },
                           onDismiss: () {
@@ -157,9 +162,14 @@ class _SmartSceneSelectAutomationListState
                         alertBody: EnableDisableAutomationDialog(
                           automationId: automation.id,
                           descriptionSelected: descriptionSelected,
+                          sceneORAutomationName: automation.name,
+                          type: automation.type,
                         ),
                         title: automation.name,
                         onConfirm: () {
+                          context
+                              .read<SmartSceneSelectBloc>()
+                              .add(const SmartSceneConfirmSelectionEvent());
                           Navigator.pop(context);
                         },
                         onDismiss: () {
@@ -191,10 +201,14 @@ class EnableDisableAutomationDialog extends StatefulWidget {
     super.key,
     required this.automationId,
     required this.descriptionSelected,
+    required this.sceneORAutomationName,
+    required this.type,
   });
 
   final String automationId;
   final String descriptionSelected;
+  final String sceneORAutomationName;
+  final String type;
 
   @override
   State<EnableDisableAutomationDialog> createState() =>
@@ -222,6 +236,14 @@ class _EnableDisableAutomationDialogState
     super.initState();
     groupValue =
         widget.descriptionSelected == 'Enable' ? 'rule_enable' : 'rule_disable';
+
+    context.read<SmartSceneSelectBloc>().add(SmartSceneEnableEvent(
+        SmartSceneEnable(
+            entityId: widget.automationId,
+            actionExecutor: groupValue!,
+            sceneORAutomationName: widget.sceneORAutomationName,
+            type: widget.type,
+            isAutomation: true)));
   }
 
   @override
@@ -251,9 +273,12 @@ class _EnableDisableAutomationDialogState
                         .read<SmartSceneSelectBloc>()
                         .add(SmartSceneEnableEvent(
                           SmartSceneEnable(
-                            entityId: widget.automationId,
+                              entityId: widget.automationId,
-                            actionExecutor: value!,
+                              actionExecutor: value!,
-                          ),
+                              sceneORAutomationName:
+                                  widget.sceneORAutomationName,
+                              type: widget.type,
+                              isAutomation: true),
                         ));
                   },
                 ),
@@ -267,6 +292,9 @@ class _EnableDisableAutomationDialogState
                         SmartSceneEnable(
                           entityId: widget.automationId,
                           actionExecutor: operation.value,
+                          sceneORAutomationName: widget.sceneORAutomationName,
+                          type: widget.type,
+                          isAutomation: true,
                         ),
                       ));
                 },

lib/features/scene/widgets/select_smart_scene/smart_tab_run_list.dart

@@ -25,6 +25,7 @@ class SmartSceneSelectTabToRunList extends StatefulWidget {
 class _SmartSceneSelectTabToRunListState
     extends State<SmartSceneSelectTabToRunList> {
   String groupValue = '';
+
   @override
   Widget build(BuildContext context) {
     return Column(
@@ -67,6 +68,13 @@ class _SmartSceneSelectTabToRunListState
               itemCount: widget.scenes.length,
               itemBuilder: (context, index) {
                 final scene = widget.scenes[index];
+                final selectedScene =
+                    context.read<SmartSceneSelectBloc>().smartSceneEnable;
+                if (selectedScene != null) {
+                  if (scene.id == selectedScene.entityId) {
+                    groupValue = scene.id;
+                  }
+                }
                 return SceneListTile(
                   padding: const EdgeInsets.symmetric(horizontal: 10),
                   leadingWidget: Image.asset(
@@ -84,12 +92,19 @@ class _SmartSceneSelectTabToRunListState
                           setState(() {
                             groupValue = value;
                           });
+
                           context
                               .read<SmartSceneSelectBloc>()
                               .add(SmartSceneEnableEvent(SmartSceneEnable(
                                 entityId: scene.id,
                                 actionExecutor: 'rule_enable',
+                                sceneORAutomationName: scene.name,
+                                type: scene.type,
+                                isAutomation: false,
                               )));
+                          context
+                              .read<SmartSceneSelectBloc>()
+                              .add(const SmartSceneConfirmSelectionEvent());
                         }
                       }),
                   onPressed: () {
@@ -101,7 +116,13 @@ class _SmartSceneSelectTabToRunListState
                         .add(SmartSceneEnableEvent(SmartSceneEnable(
                           entityId: scene.id,
                           actionExecutor: 'rule_enable',
+                          sceneORAutomationName: scene.name,
+                          type: scene.type,
+                          isAutomation: false,
                         )));
+                    context
+                        .read<SmartSceneSelectBloc>()
+                        .add(const SmartSceneConfirmSelectionEvent());
                   },
                 );
               }),

lib/my_app.dart

@@ -27,13 +27,13 @@ class MyApp extends StatelessWidget {
     return MultiBlocProvider(
       providers: [
         BlocProvider(create: (context) => AuthCubit()),
-        BlocProvider(create: (context) => CreateSceneBloc()),
-        BlocProvider(create: (context) => SceneBloc()),
-        BlocProvider(create: (context) => ProfileBloc()),
-        BlocProvider(create: (context) => SmartSceneSelectBloc()),
         BlocProvider(
           create: (context) => EffectPeriodBloc(),
         ),
+        BlocProvider(create: (context) => SmartSceneSelectBloc()),
+        BlocProvider(create: (context) => CreateSceneBloc()),
+        BlocProvider(create: (context) => SceneBloc()),
+        BlocProvider(create: (context) => ProfileBloc()),
       ],
       child: MaterialApp(
         navigatorKey: NavigationService.navigatorKey,