TF-1933 Trigger to handle hive database in main isolate when work manager changed

(cherry picked from commit 714806a751859ec9d37416a51e48ad3300ac6f73)
2023-06-27 22:04:00 +07:00
parent 9b735ebf59
commit d5cac4058a
21 changed files with 318 additions and 312 deletions
@@ -1,6 +1,6 @@

 import 'package:core/core.dart';
-import 'package:tmail_ui_user/features/offline_mode/manager/work_dispatcher.dart';
+import 'package:tmail_ui_user/features/offline_mode/work_manager/work_dispatcher.dart';
 import 'package:workmanager/workmanager.dart';

 class WorkManagerConfig {
@@ -2,5 +2,5 @@
 class WorkManagerConstants {
  static const String sendingEmailUniqueId = 'com.linagora.ios.teammail.sendingQueue';
  static const String workerTypeKey = 'worker_type';
-  static const int initialDelayTime = 2000;
+  static const int delayTime = 2000;
 }
@@ -2,59 +2,56 @@ import 'dart:async';
 import 'package:collection/collection.dart';
 import 'package:core/utils/app_logger.dart';
 import 'package:tmail_ui_user/features/offline_mode/config/work_manager_constants.dart';
-import 'package:tmail_ui_user/features/offline_mode/scheduler/one_time_work_request.dart';
-import 'package:tmail_ui_user/features/offline_mode/scheduler/periodic_work_request.dart';
-import 'package:tmail_ui_user/features/offline_mode/scheduler/work_request.dart';
-import 'package:tmail_ui_user/features/offline_mode/scheduler/worker_type.dart';
+import 'package:tmail_ui_user/features/offline_mode/exceptions/workmanager_exception.dart';
+import 'package:tmail_ui_user/features/offline_mode/work_manager/one_time_work_request.dart';
+import 'package:tmail_ui_user/features/offline_mode/work_manager/periodic_work_request.dart';
+import 'package:tmail_ui_user/features/offline_mode/work_manager/work_request.dart';
+import 'package:tmail_ui_user/features/offline_mode/work_manager/worker_type.dart';
 import 'package:workmanager/workmanager.dart';

-class WorkSchedulerController {
+class WorkManagerController {

-  static WorkSchedulerController? _instance;
+  static WorkManagerController? _instance;

-  WorkSchedulerController._();
+  WorkManagerController._();

-  factory WorkSchedulerController() => _instance ??= WorkSchedulerController._();
+  factory WorkManagerController() => _instance ??= WorkManagerController._();

-  Future<void> enqueue(WorkRequest workRequest) {
+  Future<void> enqueue(WorkRequest workRequest) async {
    try {
      log('WorkSchedulerController::enqueue():workRequest: $workRequest');
      if (workRequest is OneTimeWorkRequest) {
-        return Workmanager().registerOneOffTask(
-          workRequest.worker.uniqueId,
-          workRequest.worker.id,
-          tag: workRequest.worker.type.name,
+        await Workmanager().registerOneOffTask(
+          workRequest.uniqueId,
+          workRequest.taskId,
+          tag: workRequest.tag,
          initialDelay: workRequest.initialDelay,
          constraints: workRequest.constraints,
          backoffPolicy: workRequest.backoffPolicy,
          backoffPolicyDelay: workRequest.backoffPolicyDelay,
          outOfQuotaPolicy: workRequest.outOfQuotaPolicy,
-          inputData: workRequest.worker.inputData
+          inputData: workRequest.inputData
        );
      } if (workRequest is PeriodicWorkRequest) {
-        return Workmanager().registerPeriodicTask(
-          workRequest.worker.uniqueId,
-          workRequest.worker.id,
+        await Workmanager().registerPeriodicTask(
+          workRequest.uniqueId,
+          workRequest.taskId,
+          tag: workRequest.tag,
          frequency: workRequest.frequency,
-          tag: workRequest.worker.type.name,
          initialDelay: workRequest.initialDelay,
          constraints: workRequest.constraints,
          backoffPolicy: workRequest.backoffPolicy,
          backoffPolicyDelay: workRequest.backoffPolicyDelay,
          outOfQuotaPolicy: workRequest.outOfQuotaPolicy,
-          inputData: workRequest.worker.inputData
+          inputData: workRequest.inputData
        );
-      } else {
-        return Future.value();
      }
    } catch (e) {
      logError('WorkSchedulerController::enqueue(): EXCEPTION: $e');
-      return Future.value();
    }
  }

  Future<bool> handleBackgroundTask(String taskName, Map<String, dynamic>? inputData) async {
-    final completer = Completer<bool>();
    log('WorkSchedulerController::handleBackgroundTask():taskName: $taskName | inputData: $inputData');
    try {
      if (inputData != null && inputData.isNotEmpty) {
@@ -64,15 +61,20 @@ class WorkSchedulerController {
        final matchedType = WorkerType.values.firstWhereOrNull((type) => type.name == workerType);

        if (matchedType != null) {
-          await matchedType.usingObserver().bindDI();
-          await matchedType.usingObserver().observe(taskName, dataObject, completer);
+          final worker = matchedType.getWorker();
+          await worker.bindDI();
+          final result = await worker.doWork(taskName, dataObject);
+          return result;
+        } else {
+          return Future.error(CanNotFoundWorkerType());
        }
+      } else {
+        return Future.error(CanNotFoundInputData());
      }
    } catch (e) {
-      completer.completeError(e);
      logError('WorkSchedulerController::handleBackgroundTask():EXCEPTION: $e');
+      return Future.error(e);
    }
-    return completer.future;
  }

  Future<void> cancelByWorkType(WorkerType type) => Workmanager().cancelByTag(type.name);
@@ -1 +1,3 @@
-class CannotCompleteTaskInWorkManagerException implements Exception {}
+class CanNotFoundInputData implements Exception {}
+
+class CanNotFoundWorkerType implements Exception {}
@@ -14,11 +14,10 @@ enum SendingState {
    switch(this) {
      case SendingState.waiting:
      case SendingState.running:
+      case SendingState.success:
        return AppLocalizations.of(context).delivering;
      case SendingState.error:
        return AppLocalizations.of(context).error;
-      case SendingState.success:
-        return '';
    }
  }

@@ -26,11 +25,10 @@ enum SendingState {
    switch(this) {
      case SendingState.waiting:
      case SendingState.running:
+      case SendingState.success:
        return imagePaths.icDelivering;
      case SendingState.error:
        return imagePaths.icError;
-      case SendingState.success:
-        return '';
    }
  }

@@ -1,30 +0,0 @@
-
-import 'package:core/utils/platform_info.dart';
-import 'package:equatable/equatable.dart';
-import 'package:tmail_ui_user/features/offline_mode/config/work_manager_constants.dart';
-import 'package:tmail_ui_user/features/offline_mode/scheduler/worker_type.dart';
-
-/// Equivalent to the task or work that needs to be done in the background
-class Worker with EquatableMixin {
-
-  final String id;
-  final WorkerType type;
-  final Map<String, dynamic> data;
-
-  Worker(this.id, this.type, this.data);
-
-  String get uniqueId {
-    if (PlatformInfo.isIOS) {
-      return type.iOSUniqueId;
-    }
-    return id;
-  }
-
-  Map<String, dynamic> get inputData {
-    data.addAll({WorkManagerConstants.workerTypeKey: type.name});
-    return data;
-  }
-
-  @override
-  List<Object?> get props => [id, type, data];
-}
@@ -1,12 +1,14 @@

-import 'package:tmail_ui_user/features/offline_mode/scheduler/work_request.dart';
-import 'package:tmail_ui_user/features/offline_mode/scheduler/worker.dart';
+import 'package:tmail_ui_user/features/offline_mode/work_manager/work_request.dart';
 import 'package:workmanager/workmanager.dart';

 /// A WorkRequest for non-repeating work.
 class OneTimeWorkRequest extends WorkRequest {
-  OneTimeWorkRequest(
-    Worker worker, {
+  OneTimeWorkRequest({
+    required String uniqueId,
+    required String taskId,
+    String? tag,
+    Map<String, dynamic>? inputData,
    Duration initialDelay = Duration.zero,
    Duration backoffPolicyDelay = Duration.zero,
    ExistingWorkPolicy? existingWorkPolicy,
@@ -14,7 +16,10 @@ class OneTimeWorkRequest extends WorkRequest {
    OutOfQuotaPolicy? outOfQuotaPolicy,
    Constraints? constraints
  }) : super(
-    worker,
+    uniqueId: uniqueId,
+    taskId: taskId,
+    tag: tag,
+    inputData: inputData,
    initialDelay: initialDelay,
    backoffPolicyDelay: backoffPolicyDelay,
    existingWorkPolicy: existingWorkPolicy,
@@ -1,14 +1,16 @@

-import 'package:tmail_ui_user/features/offline_mode/scheduler/work_request.dart';
-import 'package:tmail_ui_user/features/offline_mode/scheduler/worker.dart';
+import 'package:tmail_ui_user/features/offline_mode/work_manager/work_request.dart';
 import 'package:workmanager/workmanager.dart';

 /// A WorkRequest for repeating work.
 class PeriodicWorkRequest extends WorkRequest {
  final Duration? frequency;

-  PeriodicWorkRequest(
-    Worker worker, {
+  PeriodicWorkRequest({
+    required String uniqueId,
+    required String taskId,
+    String? tag,
+    Map<String, dynamic>? inputData,
    Duration initialDelay = Duration.zero,
    Duration backoffPolicyDelay = Duration.zero,
    ExistingWorkPolicy? existingWorkPolicy,
@@ -17,7 +19,10 @@ class PeriodicWorkRequest extends WorkRequest {
    Constraints? constraints,
    this.frequency
  }) : super(
-    worker,
+    uniqueId: uniqueId,
+    taskId: taskId,
+    tag: tag,
+    inputData: inputData,
    initialDelay: initialDelay,
    backoffPolicyDelay: backoffPolicyDelay,
    existingWorkPolicy: existingWorkPolicy,
@@ -5,31 +5,28 @@ import 'package:core/presentation/state/success.dart';
 import 'package:core/utils/app_logger.dart';
 import 'package:jmap_dart_client/jmap/account_id.dart';
 import 'package:jmap_dart_client/jmap/core/session/session.dart';
+import 'package:jmap_dart_client/jmap/core/user_name.dart';
+import 'package:model/extensions/account_id_extensions.dart';
 import 'package:model/extensions/session_extension.dart';
 import 'package:model/oidc/token_oidc.dart';
 import 'package:tmail_ui_user/features/caching/config/hive_cache_config.dart';
 import 'package:tmail_ui_user/features/caching/utils/cache_utils.dart';
 import 'package:tmail_ui_user/features/composer/domain/state/send_email_state.dart';
 import 'package:tmail_ui_user/features/composer/domain/usecases/send_email_interactor.dart';
-import 'package:tmail_ui_user/features/email/domain/state/delete_sending_email_state.dart';
-import 'package:tmail_ui_user/features/home/presentation/home_bindings.dart';
 import 'package:tmail_ui_user/features/login/data/network/config/authorization_interceptors.dart';
 import 'package:tmail_ui_user/features/login/domain/state/get_authenticated_account_state.dart';
 import 'package:tmail_ui_user/features/login/domain/state/get_credential_state.dart';
 import 'package:tmail_ui_user/features/login/domain/state/get_stored_token_oidc_state.dart';
 import 'package:tmail_ui_user/features/login/domain/usecases/get_authenticated_account_interactor.dart';
 import 'package:tmail_ui_user/features/mailbox/domain/model/create_new_mailbox_request.dart';
-import 'package:tmail_ui_user/features/mailbox_dashboard/presentation/bindings/mailbox_dashboard_bindings.dart';
 import 'package:tmail_ui_user/features/offline_mode/bindings/sending_email_interactor_bindings.dart';
-import 'package:tmail_ui_user/features/offline_mode/exceptions/workmanager_exception.dart';
 import 'package:tmail_ui_user/features/offline_mode/manager/sending_email_cache_manager.dart';
 import 'package:tmail_ui_user/features/offline_mode/model/sending_state.dart';
-import 'package:tmail_ui_user/features/offline_mode/observer/work_observer.dart';
+import 'package:tmail_ui_user/features/offline_mode/work_manager/worker.dart';
 import 'package:tmail_ui_user/features/sending_queue/domain/extensions/sending_email_extension.dart';
 import 'package:tmail_ui_user/features/sending_queue/domain/model/sending_email.dart';
-import 'package:tmail_ui_user/features/sending_queue/domain/state/update_sending_email_state.dart';
-import 'package:tmail_ui_user/features/sending_queue/domain/usecases/delete_sending_email_interactor.dart';
-import 'package:tmail_ui_user/features/sending_queue/domain/usecases/update_sending_email_interactor.dart';
+import 'package:tmail_ui_user/features/sending_queue/presentation/bindings/sending_queue_bindings.dart';
+import 'package:tmail_ui_user/features/sending_queue/presentation/bindings/sending_queue_interactor_bindings.dart';
 import 'package:tmail_ui_user/features/sending_queue/presentation/utils/sending_queue_isolate_manager.dart';
 import 'package:tmail_ui_user/features/session/domain/extensions/session_extensions.dart';
 import 'package:tmail_ui_user/features/session/domain/state/get_session_state.dart';
@@ -37,37 +34,39 @@ import 'package:tmail_ui_user/features/session/domain/usecases/get_session_inter
 import 'package:tmail_ui_user/main/bindings/main_bindings.dart';
 import 'package:tmail_ui_user/main/routes/route_navigation.dart';

-class SendingEmailObserver extends WorkObserver {
-
-  AccountId? _currentAccountId;
-  Session? _currentSession;
-  SendingEmail? _sendingEmail;
+class SendingEmailWorker extends Worker {

  SendEmailInteractor? _sendEmailInteractor;
  GetAuthenticatedAccountInteractor? _getAuthenticatedAccountInteractor;
  DynamicUrlInterceptors? _dynamicUrlInterceptors;
  AuthorizationInterceptors? _authorizationInterceptors;
  GetSessionInteractor? _getSessionInteractor;
-  DeleteSendingEmailInteractor? _deleteSendingEmailInteractor;
  SendingQueueIsolateManager? _sendingQueueIsolateManager;
-  UpdateSendingEmailInteractor? _updateSendingEmailInteractor;
  SendingEmailCacheManager? _sendingEmailCacheManager;

-  Completer<bool>? _completer;
+  late Completer<bool> _completer;
+  late SendingEmail _sendingEmail;

-  static SendingEmailObserver? _instance;
+  AccountId? _currentAccountId;
+  Session? _currentSession;

-  SendingEmailObserver._();
+  static SendingEmailWorker? _instance;

-  factory SendingEmailObserver() => _instance ??= SendingEmailObserver._();
+  SendingEmailWorker._();
+
+  factory SendingEmailWorker() => _instance ??= SendingEmailWorker._();

  @override
-  Future<void> observe(String taskId, Map<String, dynamic> inputData, Completer<bool> completer) async {
-    _completer = completer;
+  Future<bool> doWork(String taskId, Map<String, dynamic> inputData) {
+    _completer = Completer<bool>();
    _sendingEmail = SendingEmail.fromJson(inputData);
    log('SendingEmailObserver::observe():_sendingEmail: $_sendingEmail');
-    _updatingSendingStateToMainUI();
+    _updatingSendingStateToMainUI(
+      sendingId: _sendingEmail.sendingId,
+      sendingState: SendingState.running
+    );
    _getAuthenticatedAccount();
+    return _completer.future;
  }

  @override
@@ -77,17 +76,13 @@ class SendingEmailObserver extends WorkObserver {
      HiveCacheConfig().setUp()
    ]);

-    await Future.sync(() {
-      HomeBindings().dependencies();
-      MailboxDashBoardBindings().dependencies();
-      SendEmailInteractorBindings().dependencies();
-    });
+    SendingQueueInteractorBindings().dependencies();
+    SendEmailInteractorBindings().dependencies();
+    SendingQueueBindings().dependencies();

-    await _getInteractorBindings();
+    _getInteractorBindings();

    await _sendingEmailCacheManager?.closeSendingEmailHiveCacheBox();
-
-    return Future.value();
  }

  @override
@@ -95,14 +90,11 @@ class SendingEmailObserver extends WorkObserver {
    log('SendingEmailObserver::_handleFailureViewState(): $failure');
    if (failure is SendEmailFailure) {
      _handleSendEmailFailure(failure);
-    } else if (failure is DeleteSendingEmailFailure) {
-      _handleDeleteSendingEmailFailure(failure);
    } else if (failure is GetAuthenticatedAccountFailure ||
        failure is NoAuthenticatedAccountFailure ||
        failure is GetSessionFailure ||
        failure is GetStoredTokenOidcFailure ||
-        failure is GetCredentialFailure ||
-        failure is UpdateSendingEmailFailure) {
+        failure is GetCredentialFailure) {
      _handleTaskFailureInWorkManager();
    }
  }
@@ -118,10 +110,6 @@ class SendingEmailObserver extends WorkObserver {
      _handleGetAccountByBasicAuthSuccess(success);
    } else if (success is SendEmailSuccess) {
      _handleSendEmailSuccess(success);
-    } else if (success is DeleteSendingEmailSuccess) {
-      _handleDeleteSendingEmailSuccess(success);
-    } else if (success is UpdateSendingEmailSuccess) {
-      _handleUpdateStoredSendingEmailSuccess(success);
    }
  }

@@ -131,27 +119,22 @@ class SendingEmailObserver extends WorkObserver {
    _handleTaskFailureInWorkManager();
  }

-  Future<void> _getInteractorBindings() async {
-    try {
-      _getAuthenticatedAccountInteractor = getBinding<GetAuthenticatedAccountInteractor>();
-      _dynamicUrlInterceptors = getBinding<DynamicUrlInterceptors>();
-      _authorizationInterceptors = getBinding<AuthorizationInterceptors>();
-      _getSessionInteractor = getBinding<GetSessionInteractor>();
-      _sendEmailInteractor = getBinding<SendEmailInteractor>();
-      _deleteSendingEmailInteractor = getBinding<DeleteSendingEmailInteractor>();
-      _sendingQueueIsolateManager = getBinding<SendingQueueIsolateManager>();
-      _updateSendingEmailInteractor = getBinding<UpdateSendingEmailInteractor>();
-      _sendingEmailCacheManager = getBinding<SendingEmailCacheManager>();
-    } catch (e) {
-      logError('SendingEmailObserver::_getInteractorBindings(): ${e.toString()}');
-      _handleTaskFailureInWorkManager();
-    }
+  void _getInteractorBindings() {
+    _getAuthenticatedAccountInteractor = getBinding<GetAuthenticatedAccountInteractor>();
+    _dynamicUrlInterceptors = getBinding<DynamicUrlInterceptors>();
+    _authorizationInterceptors = getBinding<AuthorizationInterceptors>();
+    _getSessionInteractor = getBinding<GetSessionInteractor>();
+    _sendEmailInteractor = getBinding<SendEmailInteractor>();
+    _sendingQueueIsolateManager = getBinding<SendingQueueIsolateManager>();
+    _sendingEmailCacheManager = getBinding<SendingEmailCacheManager>();
  }

  void _updatingSendingStateToMainUI({String? sendingId, SendingState? sendingState}) {
    final eventAction = _generateEventAction(
-      sendingId ?? _sendingEmail!.sendingId,
-      sendingState ?? _sendingEmail!.sendingState
+      sendingId ?? _sendingEmail.sendingId,
+      sendingState ?? _sendingEmail.sendingState,
+      accountId: _currentAccountId,
+      userName: _currentSession?.username
    );
    log('SendingEmailObserver::_updatingSendingStateToMainUI():eventAction: $eventAction');
    _sendingQueueIsolateManager?.addEvent(eventAction);
@@ -169,9 +152,9 @@ class SendingEmailObserver extends WorkObserver {
    _currentSession = success.session;
    _currentAccountId = success.session.personalAccount.accountId;
    final apiUrl = success.session.getQualifiedApiUrl(baseUrl: _dynamicUrlInterceptors?.jmapUrl);
-    if (apiUrl.isNotEmpty) {
+    if (apiUrl.isNotEmpty && _currentSession != null && _currentAccountId != null) {
      _dynamicUrlInterceptors?.changeBaseUrl(apiUrl);
-      _sendEmailAction();
+      _sendEmailAction(_currentAccountId!, _currentSession!);
    } else {
      _handleTaskFailureInWorkManager();
    }
@@ -187,23 +170,23 @@ class SendingEmailObserver extends WorkObserver {
    _getSessionAction();
  }

-  void _sendEmailAction() {
+  void _sendEmailAction(AccountId accountId, Session session) {
    consumeState(
      _sendEmailInteractor!.execute(
-        _currentSession!,
-        _currentAccountId!,
-        _sendingEmail!.toEmailRequest(),
+        session,
+        accountId,
+        _sendingEmail.toEmailRequest(),
        mailboxRequest: _getMailboxRequest()
      )
    );
  }

  CreateNewMailboxRequest? _getMailboxRequest() {
-    if (_sendingEmail!.mailboxNameRequest != null &&
-        _sendingEmail!.creationIdRequest != null) {
+    if (_sendingEmail.mailboxNameRequest != null &&
+        _sendingEmail.creationIdRequest != null) {
      return CreateNewMailboxRequest(
-        _sendingEmail!.creationIdRequest!,
-        _sendingEmail!.mailboxNameRequest!);
+        _sendingEmail.creationIdRequest!,
+        _sendingEmail.mailboxNameRequest!);
    } else {
      return null;
    }
@@ -220,80 +203,45 @@ class SendingEmailObserver extends WorkObserver {
  }

  void _handleSendEmailSuccess(SendEmailSuccess success) {
-    _updateStoredSendingEmail(SendingState.success);
-  }
-
-  void _handleSendEmailFailure(SendEmailFailure failure) {
-    _updateStoredSendingEmail(SendingState.error);
-  }
-
-  void _deleteSendingEmailAction() {
-    consumeState(
-      _deleteSendingEmailInteractor!.execute(
-        _currentAccountId!,
-        _currentSession!.username,
-        _sendingEmail!.sendingId
-      )
-    );
-  }
-
-  void _handleDeleteSendingEmailSuccess(DeleteSendingEmailSuccess success) {
+    _updatingSendingStateToMainUI(sendingState: SendingState.success);
    _handleTaskSuccessInWorkManager();
  }

-  void _handleDeleteSendingEmailFailure(DeleteSendingEmailFailure failure) {
-    _handleTaskFailureInWorkManager();
-  }
-
-  void _updateStoredSendingEmail(SendingState newState) {
-    log('SendingEmailObserver::_updateStoredSendingEmail():newState: $newState');
-    consumeState(
-      _updateSendingEmailInteractor!.execute(
-        _currentAccountId!,
-        _currentSession!.username,
-        _sendingEmail!.updatingSendingState(newState)
-      )
-    );
-  }
-
-  void _handleUpdateStoredSendingEmailSuccess(UpdateSendingEmailSuccess success) {
-    log('SendingEmailObserver::_handleUpdateStoredSendingEmailSuccess(): $success');
-    if (success.newSendingEmail.isSuccess) {
-      _deleteSendingEmailAction();
-    } else {
-      _updatingSendingStateToMainUI(
-        sendingState: success.newSendingEmail.sendingState,
-        sendingId: success.newSendingEmail.sendingId);
-    }
+  void _handleSendEmailFailure(SendEmailFailure failure) {
+    _updatingSendingStateToMainUI(sendingState: SendingState.error);
+    _handleTaskErrorInWorkManager(failure.exception);
  }

  void _handleTaskFailureInWorkManager() async {
    log('SendingEmailObserver::_handleTaskFailureInWorkManager():');
-    _updatingSendingStateToMainUI(sendingState: SendingState.error);
-
    await Future.delayed(
      const Duration(milliseconds: 1000),
-      () {
-        _completer?.completeError(CannotCompleteTaskInWorkManagerException());
-        _sendingEmail = null;
-        _completer = null;
-      }
+      () => _completer.complete(false)
+    );
+  }
+
+  void _handleTaskErrorInWorkManager(dynamic error) async {
+    log('SendingEmailObserver::_handleTaskErrorInWorkManager():');
+    await Future.delayed(
+      const Duration(milliseconds: 1000),
+      () => _completer.completeError(error)
    );
  }

  void _handleTaskSuccessInWorkManager() async {
    log('SendingEmailObserver::_handleTaskSuccessInWorkManager():');
-    _updatingSendingStateToMainUI(sendingState: SendingState.success);
-
    await Future.delayed(
      const Duration(milliseconds: 1000),
-      () {
-        _completer?.complete(true);
-        _sendingEmail = null;
-        _completer = null;
-      }
+      () => _completer.complete(true)
    );
  }

-  String _generateEventAction(String sendingId, SendingState sendingState) => TupleKey(sendingId, sendingState.name).toString();
+  String _generateEventAction(
+    String sendingId,
+    SendingState sendingState,
+    {
+      AccountId? accountId,
+      UserName? userName
+    }
+  ) => TupleKey(sendingId, sendingState.name, accountId?.asString, userName?.value).toString();
 }
@@ -1,8 +1,8 @@

-import 'package:tmail_ui_user/features/offline_mode/controller/work_scheduler_controller.dart';
+import 'package:tmail_ui_user/features/offline_mode/controller/work_manager_controller.dart';
 import 'package:workmanager/workmanager.dart';

@pragma('vm:entry-point')
 void callbackDispatcher() {
-  Workmanager().executeTask(WorkSchedulerController().handleBackgroundTask);
+  Workmanager().executeTask(WorkManagerController().handleBackgroundTask);
 }
@@ -1,11 +1,13 @@

 import 'package:equatable/equatable.dart';
-import 'package:tmail_ui_user/features/offline_mode/scheduler/worker.dart';
 import 'package:workmanager/workmanager.dart';

 /// Represents the scheduling of requests
 abstract class WorkRequest with EquatableMixin {
-  final Worker worker;
+  final String uniqueId;
+  final String taskId;
+  final String? tag;
+  final Map<String, dynamic>? inputData;
  final Duration initialDelay;
  final Duration backoffPolicyDelay;
  final ExistingWorkPolicy? existingWorkPolicy;
@@ -13,21 +15,25 @@ abstract class WorkRequest with EquatableMixin {
  final OutOfQuotaPolicy? outOfQuotaPolicy;
  final Constraints? constraints;

-  WorkRequest(
-    this.worker,
-    {
-      this.initialDelay = Duration.zero,
-      this.backoffPolicyDelay = Duration.zero,
-      this.existingWorkPolicy,
-      this.backoffPolicy,
-      this.outOfQuotaPolicy,
-      this.constraints
-    }
-  );
+  WorkRequest( {
+    required this.uniqueId,
+    required this.taskId,
+    this.tag,
+    this.inputData,
+    this.initialDelay = Duration.zero,
+    this.backoffPolicyDelay = Duration.zero,
+    this.existingWorkPolicy,
+    this.backoffPolicy,
+    this.outOfQuotaPolicy,
+    this.constraints
+  });

  @override
  List<Object?> get props => [
-    worker,
+    uniqueId,
+    taskId,
+    tag,
+    inputData,
    initialDelay,
    backoffPolicyDelay,
    existingWorkPolicy,
@@ -4,10 +4,10 @@ import 'package:core/presentation/state/success.dart';
 import 'package:core/utils/app_logger.dart';
 import 'package:dartz/dartz.dart';

-abstract class WorkObserver {
+abstract class Worker {
  Future<void> bindDI();

-  Future<void> observe(String taskId, Map<String, dynamic> inputData, Completer<bool> completer);
+  Future<bool> doWork(String taskId, Map<String, dynamic> inputData);

  void consumeState(Stream<Either<Failure, Success>> newStateStream) {
    newStateStream.listen(
@@ -1,15 +1,15 @@

 import 'package:tmail_ui_user/features/offline_mode/config/work_manager_constants.dart';
-import 'package:tmail_ui_user/features/offline_mode/observer/sending_email_observer.dart';
-import 'package:tmail_ui_user/features/offline_mode/observer/work_observer.dart';
+import 'package:tmail_ui_user/features/offline_mode/work_manager/sending_email_worker.dart';
+import 'package:tmail_ui_user/features/offline_mode/work_manager/worker.dart';

 enum WorkerType {
  sendingEmail;

-  WorkObserver usingObserver() {
+  Worker getWorker() {
    switch(this) {
      case WorkerType.sendingEmail:
-        return SendingEmailObserver();
+        return SendingEmailWorker();
    }
  }