Implement the power management bloc .

Author: amitamrutiya

lib/Blocs/power_management_bloc/power_management_bloc.dart

@@ -0,0 +1,97 @@
+import 'package:battery_plus/battery_plus.dart';
+import 'package:bloc/bloc.dart';
+import 'package:equatable/equatable.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:wakelock/wakelock.dart';
+
+part 'power_management_event.dart';
+part 'power_management_state.dart';
+
+class PowerManagementBloc
+    extends Bloc<PowerManagementEvent, PowerManagementState> {
+  PowerManagementBloc() : super(PowerManagementState.initial()) {
+    on<PowerManagementEvent>((event, emit) {});
+
+    on<SetWifiOnlyDownloadEvent>(
+      (event, emit) => _setWifiOnlyDownloadEvent(event, emit),
+    );
+
+    on<SetShutDownWhenFinishDownloadEvent>(
+      (event, emit) => _setShutDownWhenFinishDownloadEvent(event, emit),
+    );
+
+    on<SetKeepRunningBackgroundEvent>(
+      (event, emit) => _setKeepRunningBackgroundEvent(event, emit),
+    );
+
+    on<SetKeepCpuAwakeEvent>(
+      (event, emit) => _setKeepCpuAwakeEvent(event, emit),
+    );
+
+    on<SetDownloadChargingConnectedEvent>(
+      (event, emit) => _setDownloadChargingConnectedEvent(event, emit),
+    );
+
+    on<SetShutDownWifiEvent>(
+      (event, emit) => _setShutDownWifiEvent(event, emit),
+    );
+
+    on<SetBatteryLimitLevelEvent>(
+      (event, emit) => _setBatteryLimitLevelEvent(event, emit),
+    );
+  }
+
+  void _setWifiOnlyDownloadEvent(
+    SetWifiOnlyDownloadEvent event,
+    Emitter<PowerManagementState> emit,
+  ) {
+    emit(state.copyWith(wifiOnlyDownload: event.wifiOnlyDownload));
+  }
+
+  void _setShutDownWhenFinishDownloadEvent(
+    SetShutDownWhenFinishDownloadEvent event,
+    Emitter<PowerManagementState> emit,
+  ) {
+    emit(state.copyWith(
+        shutDownWhenFinishDownload: event.shutDownWhenFinishDownload));
+  }
+
+  void _setKeepRunningBackgroundEvent(
+    SetKeepRunningBackgroundEvent event,
+    Emitter<PowerManagementState> emit,
+  ) {
+    emit(state.copyWith(keepRunningBackground: event.keepRunningBackground));
+  }
+
+  void _setKeepCpuAwakeEvent(
+    SetKeepCpuAwakeEvent event,
+    Emitter<PowerManagementState> emit,
+  ) {
+    Wakelock.toggle(enable: event.keepCpuAwake);
+    emit(state.copyWith(keepCpuAwake: event.keepCpuAwake));
+  }
+
+  void _setDownloadChargingConnectedEvent(
+    SetDownloadChargingConnectedEvent event,
+    Emitter<PowerManagementState> emit,
+  ) {
+    emit(state.copyWith(
+      downloadChargingConnected: event.downloadChargingConnected,
+      currentBatteryState: event.currentBatteryState,
+    ));
+  }
+
+  void _setShutDownWifiEvent(
+    SetShutDownWifiEvent event,
+    Emitter<PowerManagementState> emit,
+  ) {
+    emit(state.copyWith(shutDownWifi: event.shutDownWifi));
+  }
+
+  void _setBatteryLimitLevelEvent(
+      SetBatteryLimitLevelEvent event, Emitter<PowerManagementState> emit) {
+    emit(state.copyWith(
+      batteryLimitLevel: event.batteryLimitLevel,
+    ));
+  }
+}

lib/Blocs/power_management_bloc/power_management_event.dart

@@ -0,0 +1,76 @@
+part of 'power_management_bloc.dart';
+
+abstract class PowerManagementEvent extends Equatable {
+  const PowerManagementEvent();
+
+  @override
+  List<Object> get props => [];
+}
+
+class SetWifiOnlyDownloadEvent extends PowerManagementEvent {
+  final bool wifiOnlyDownload;
+
+  const SetWifiOnlyDownloadEvent({required this.wifiOnlyDownload});
+
+  @override
+  List<Object> get props => [wifiOnlyDownload];
+}
+
+class SetShutDownWhenFinishDownloadEvent extends PowerManagementEvent {
+  final bool shutDownWhenFinishDownload;
+
+  const SetShutDownWhenFinishDownloadEvent(
+      {required this.shutDownWhenFinishDownload});
+
+  @override
+  List<Object> get props => [shutDownWhenFinishDownload];
+}
+
+class SetKeepRunningBackgroundEvent extends PowerManagementEvent {
+  final bool keepRunningBackground;
+
+  const SetKeepRunningBackgroundEvent({required this.keepRunningBackground});
+
+  @override
+  List<Object> get props => [keepRunningBackground];
+}
+
+class SetKeepCpuAwakeEvent extends PowerManagementEvent {
+  final bool keepCpuAwake;
+
+  const SetKeepCpuAwakeEvent({required this.keepCpuAwake});
+
+  @override
+  List<Object> get props => [keepCpuAwake];
+}
+
+class SetShutDownWifiEvent extends PowerManagementEvent {
+  final bool shutDownWifi;
+
+  const SetShutDownWifiEvent({required this.shutDownWifi});
+
+  @override
+  List<Object> get props => [shutDownWifi];
+}
+
+class SetDownloadChargingConnectedEvent extends PowerManagementEvent {
+  final bool? downloadChargingConnected;
+  final BatteryState? currentBatteryState;
+  const SetDownloadChargingConnectedEvent(
+      {this.downloadChargingConnected, this.currentBatteryState});
+
+  @override
+  List<Object> get props => [
+        downloadChargingConnected ?? false,
+        currentBatteryState ?? BatteryState.unknown
+      ];
+}
+
+class SetBatteryLimitLevelEvent extends PowerManagementEvent {
+  final int batteryLimitLevel;
+
+  const SetBatteryLimitLevelEvent({required this.batteryLimitLevel});
+
+  @override
+  List<Object> get props => [batteryLimitLevel];
+}

lib/Blocs/power_management_bloc/power_management_state.dart

@@ -0,0 +1,70 @@
+part of 'power_management_bloc.dart';
+
+class PowerManagementState extends Equatable {
+  final bool wifiOnlyDownload;
+  final bool shutDownWhenFinishDownload;
+  final bool keepRunningBackground;
+  final bool keepCpuAwake;
+  final bool downloadChargingConnected;
+  final bool shutDownWifi;
+  final BatteryState currentBatteryState;
+  final int batteryLimitLevel;
+
+  const PowerManagementState({
+    required this.wifiOnlyDownload,
+    required this.shutDownWhenFinishDownload,
+    required this.keepRunningBackground,
+    required this.keepCpuAwake,
+    required this.downloadChargingConnected,
+    required this.currentBatteryState,
+    required this.shutDownWifi,
+    required this.batteryLimitLevel,
+  });
+
+  factory PowerManagementState.initial() => PowerManagementState(
+        wifiOnlyDownload: false,
+        shutDownWhenFinishDownload: false,
+        keepRunningBackground: false,
+        keepCpuAwake: false,
+        downloadChargingConnected: false,
+        currentBatteryState: BatteryState.unknown,
+        shutDownWifi: false,
+        batteryLimitLevel: 0,
+      );
+
+  PowerManagementState copyWith({
+    bool? wifiOnlyDownload,
+    bool? shutDownWhenFinishDownload,
+    bool? keepRunningBackground,
+    bool? keepCpuAwake,
+    bool? downloadChargingConnected,
+    BatteryState? currentBatteryState,
+    bool? shutDownWifi,
+    int? batteryLimitLevel,
+  }) =>
+      PowerManagementState(
+        wifiOnlyDownload: wifiOnlyDownload ?? this.wifiOnlyDownload,
+        shutDownWhenFinishDownload:
+            shutDownWhenFinishDownload ?? this.shutDownWhenFinishDownload,
+        keepRunningBackground:
+            keepRunningBackground ?? this.keepRunningBackground,
+        keepCpuAwake: keepCpuAwake ?? this.keepCpuAwake,
+        downloadChargingConnected:
+            downloadChargingConnected ?? this.downloadChargingConnected,
+        currentBatteryState: currentBatteryState ?? this.currentBatteryState,
+        shutDownWifi: shutDownWifi ?? this.shutDownWifi,
+        batteryLimitLevel: batteryLimitLevel ?? this.batteryLimitLevel,
+      );
+
+  @override
+  List<Object> get props => [
+        wifiOnlyDownload,
+        shutDownWhenFinishDownload,
+        keepRunningBackground,
+        keepCpuAwake,
+        downloadChargingConnected,
+        currentBatteryState,
+        shutDownWifi,
+        batteryLimitLevel,
+      ];
+}