Migrate remaining jobs to WorkManager

Signed-off-by: Chris Narkiewicz <hello@ezaquarii.com>

src/main/java/com/nextcloud/client/jobs/AccountRemovalWork.kt

@@ -0,0 +1,193 @@
+/*
+* Nextcloud Android client application
+*
+* @author Tobias Kaminsky
+* @author Chris Narkiewicz
+*
+* Copyright (C) 2017 Tobias Kaminsky
+* Copyright (C) 2017 Nextcloud GmbH.
+* Copyright (C) 2020 Chris Narkiewicz <hello@ezaquarii.com>
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Affero General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU Affero General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+package com.nextcloud.client.jobs
+
+import android.accounts.Account
+import android.content.Context
+import android.os.Build
+import android.provider.DocumentsContract
+import android.text.TextUtils
+import androidx.work.Worker
+import androidx.work.WorkerParameters
+import com.google.gson.Gson
+import com.nextcloud.client.account.User
+import com.nextcloud.client.account.UserAccountManager
+import com.nextcloud.client.core.Clock
+import com.nextcloud.client.preferences.AppPreferencesImpl
+import com.nextcloud.java.util.Optional
+import com.owncloud.android.MainApp
+import com.owncloud.android.R
+import com.owncloud.android.datamodel.ArbitraryDataProvider
+import com.owncloud.android.datamodel.FileDataStorageManager
+import com.owncloud.android.datamodel.FilesystemDataProvider
+import com.owncloud.android.datamodel.PushConfigurationState
+import com.owncloud.android.datamodel.SyncedFolderProvider
+import com.owncloud.android.datamodel.UploadsStorageManager
+import com.owncloud.android.lib.common.OwnCloudClient
+import com.owncloud.android.lib.common.OwnCloudClientManagerFactory
+import com.owncloud.android.lib.common.utils.Log_OC
+import com.owncloud.android.lib.resources.users.RemoteWipeSuccessRemoteOperation
+import com.owncloud.android.ui.activity.ContactsPreferenceActivity
+import com.owncloud.android.ui.activity.ManageAccountsActivity
+import com.owncloud.android.ui.events.AccountRemovedEvent
+import com.owncloud.android.utils.EncryptionUtils
+import com.owncloud.android.utils.FileStorageUtils
+import com.owncloud.android.utils.PushUtils
+import org.greenrobot.eventbus.EventBus
+import java.io.File
+import java.util.ArrayList
+
+/**
+ * Removes account and all local files
+ */
+class AccountRemovalWork(
+    private val context: Context,
+    params: WorkerParameters,
+    private val uploadsStorageManager: UploadsStorageManager,
+    private val userAccountManager: UserAccountManager,
+    private val backgroundJobManager: BackgroundJobManager,
+    private val clock: Clock,
+    private val eventBus: EventBus
+) : Worker(context, params) {
+
+    companion object {
+        const val TAG = "AccountRemovalJob"
+        const val ACCOUNT = "account"
+        const val REMOTE_WIPE = "remote_wipe"
+    }
+
+    @Suppress("ReturnCount") // legacy code
+    override fun doWork(): Result {
+        val accountName = inputData.getString(ACCOUNT) ?: ""
+        if (TextUtils.isEmpty(accountName)) { // didn't receive account to delete
+            return Result.failure()
+        }
+        val optionalUser = userAccountManager.getUser(accountName)
+        if (!optionalUser.isPresent) { // trying to delete non-existing user
+            return Result.failure()
+        }
+        val remoteWipe = inputData.getBoolean(REMOTE_WIPE, false)
+        val arbitraryDataProvider = ArbitraryDataProvider(context.contentResolver)
+        val user = optionalUser.get()
+        backgroundJobManager.cancelPeriodicContactsBackup(user)
+        val userRemoved = userAccountManager.removeUser(user)
+        if (userRemoved) {
+            eventBus.post(AccountRemovedEvent())
+        }
+        val storageManager = FileDataStorageManager(user.toPlatformAccount(), context.contentResolver)
+        // remove all files
+        removeFiles(user, storageManager)
+        // delete all database entries
+        storageManager.deleteAllFiles()
+        // disable daily backup
+        arbitraryDataProvider.storeOrUpdateKeyValue(
+            user.accountName,
+            ContactsPreferenceActivity.PREFERENCE_CONTACTS_AUTOMATIC_BACKUP,
+            "false"
+        )
+        // unregister push notifications
+        unregisterPushNotifications(context, user, arbitraryDataProvider)
+        // remove pending account removal
+        arbitraryDataProvider.deleteKeyForAccount(user.accountName, ManageAccountsActivity.PENDING_FOR_REMOVAL)
+        // remove synced folders set for account
+        remoceSyncedFolders(context, user.toPlatformAccount(), clock)
+        // delete all uploads for account
+        uploadsStorageManager.removeAccountUploads(user.toPlatformAccount())
+        // delete stored E2E keys
+        arbitraryDataProvider.deleteKeyForAccount(user.accountName, EncryptionUtils.PRIVATE_KEY)
+        arbitraryDataProvider.deleteKeyForAccount(user.accountName, EncryptionUtils.PUBLIC_KEY)
+        if (remoteWipe) {
+            val optionalClient = createClient(user)
+            if (optionalClient.isPresent) {
+                val client = optionalClient.get()
+                val authToken = client.credentials.authToken
+                RemoteWipeSuccessRemoteOperation(authToken).execute(client)
+            }
+        }
+        // notify Document Provider
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+            val authority = context.resources.getString(R.string.document_provider_authority)
+            val rootsUri = DocumentsContract.buildRootsUri(authority)
+            context.contentResolver.notifyChange(rootsUri, null)
+        }
+        return Result.success()
+    }
+
+    private fun unregisterPushNotifications(
+        context: Context,
+        user: User,
+        arbitraryDataProvider: ArbitraryDataProvider
+    ) {
+        val arbitraryDataPushString = arbitraryDataProvider.getValue(user.toPlatformAccount(),
+            PushUtils.KEY_PUSH)
+        val pushServerUrl = context.resources.getString(R.string.push_server_url)
+        if (!TextUtils.isEmpty(arbitraryDataPushString) && !TextUtils.isEmpty(pushServerUrl)) {
+            val gson = Gson()
+            val pushArbitraryData = gson.fromJson(arbitraryDataPushString,
+                PushConfigurationState::class.java)
+            pushArbitraryData.isShouldBeDeleted = true
+            arbitraryDataProvider.storeOrUpdateKeyValue(user.accountName, PushUtils.KEY_PUSH,
+                gson.toJson(pushArbitraryData))
+            PushUtils.pushRegistrationToServer(userAccountManager, pushArbitraryData.getPushToken())
+        }
+    }
+
+    private fun remoceSyncedFolders(context: Context, account: Account, clock: Clock) {
+        val syncedFolderProvider = SyncedFolderProvider(context.contentResolver,
+            AppPreferencesImpl.fromContext(context),
+            clock)
+        val syncedFolders = syncedFolderProvider.syncedFolders
+        val syncedFolderIds: MutableList<Long> = ArrayList()
+        for (syncedFolder in syncedFolders) {
+            if (syncedFolder.account == account.name) {
+                syncedFolderIds.add(syncedFolder.id)
+            }
+        }
+        syncedFolderProvider.deleteSyncFoldersForAccount(account)
+        val filesystemDataProvider = FilesystemDataProvider(context.contentResolver)
+        for (syncedFolderId in syncedFolderIds) {
+            filesystemDataProvider.deleteAllEntriesForSyncedFolder(java.lang.Long.toString(syncedFolderId))
+        }
+    }
+
+    private fun removeFiles(user: User, storageManager: FileDataStorageManager) {
+        val tempDir = File(FileStorageUtils.getTemporalPath(user.accountName))
+        val saveDir = File(FileStorageUtils.getSavePath(user.accountName))
+        FileStorageUtils.deleteRecursively(tempDir, storageManager)
+        FileStorageUtils.deleteRecursively(saveDir, storageManager)
+    }
+
+    private fun createClient(user: User): Optional<OwnCloudClient> {
+        @Suppress("TooGenericExceptionCaught") // needs migration to newer api to get rid of exceptions
+        return try {
+            val context = MainApp.getAppContext()
+            val factory = OwnCloudClientManagerFactory.getDefaultSingleton()
+            val client = factory.getClientFor(user.toOwnCloudAccount(), context)
+            Optional.of(client)
+        } catch (e: Exception) {
+            Log_OC.e(this, "Could not create client", e)
+            Optional.empty()
+        }
+    }
+}

src/main/java/com/nextcloud/client/jobs/BackgroundJobFactory.kt

@@ -38,6 +38,7 @@ import com.nextcloud.client.preferences.AppPreferences
 import com.owncloud.android.datamodel.ArbitraryDataProvider
 import com.owncloud.android.datamodel.SyncedFolderProvider
 import com.owncloud.android.datamodel.UploadsStorageManager
+import org.greenrobot.eventbus.EventBus
 import javax.inject.Inject
 import javax.inject.Provider
 
@@ -58,7 +59,8 @@ class BackgroundJobFactory @Inject constructor(
     private val dataProvider: ArbitraryDataProvider,
     private val uploadsStorageManager: UploadsStorageManager,
     private val connectivityService: ConnectivityService,
-    private val notificationManager: NotificationManager
+    private val notificationManager: NotificationManager,
+    private val eventBus: EventBus
 ) : WorkerFactory() {
 
     override fun createWorker(
@@ -81,6 +83,7 @@ class BackgroundJobFactory @Inject constructor(
             OfflineSyncWork::class -> createOfflineSyncWork(context, workerParameters)
             MediaFoldersDetectionWork::class -> createMediaFoldersDetectionWork(context, workerParameters)
             NotificationWork::class -> createNotificationWork(context, workerParameters)
+            AccountRemovalWork::class -> createAccountRemovalWorl(context, workerParameters)
             else -> null // caller falls back to default factory
         }
     }
@@ -170,6 +173,18 @@ class BackgroundJobFactory @Inject constructor(
             params,
             notificationManager,
             accountManager
-            )
+        )
+    }
+
+    private fun createAccountRemovalWorl(context: Context, params: WorkerParameters): AccountRemovalWork {
+        return AccountRemovalWork(
+            context,
+            params,
+            uploadsStorageManager,
+            accountManager,
+            backgroundJobManager.get(),
+            clock,
+            eventBus
+        )
     }
 }

src/main/java/com/nextcloud/client/jobs/BackgroundJobManager.kt

@@ -98,6 +98,7 @@ interface BackgroundJobManager {
     fun startMediaFoldersDetectionJob()
 
     fun startNotificationJob(subject: String, signature: String)
+    fun startAccountRemovalJob(accountName: String, remoteWipe: Boolean)
 
     fun scheduleTestJob()
     fun startImmediateTestJob()

src/main/java/com/nextcloud/client/jobs/BackgroundJobManagerImpl.kt

@@ -74,6 +74,8 @@ internal class BackgroundJobManagerImpl(
         const val JOB_PERIODIC_MEDIA_FOLDER_DETECTION = "periodic_media_folder_detection"
         const val JOB_IMMEDIATE_MEDIA_FOLDER_DETECTION = "immediate_media_folder_detection"
         const val JOB_NOTIFICATION = "notification"
+        const val JOB_ACCOUNT_REMOVAL = "account_removal"
+
         const val JOB_TEST = "test_job"
 
         const val MAX_CONTENT_TRIGGER_DELAY_MS = 1500L
@@ -352,6 +354,19 @@ internal class BackgroundJobManagerImpl(
         workManager.enqueue(request)
     }
 
+    override fun startAccountRemovalJob(accountName: String, remoteWipe: Boolean) {
+        val data = Data.Builder()
+            .putString(AccountRemovalWork.ACCOUNT, accountName)
+            .putBoolean(AccountRemovalWork.REMOTE_WIPE, remoteWipe)
+            .build()
+
+        val request = oneTimeRequestBuilder(AccountRemovalWork::class, JOB_ACCOUNT_REMOVAL)
+            .setInputData(data)
+            .build()
+
+        workManager.enqueue(request)
+    }
+
     override fun scheduleTestJob() {
         val request = periodicRequestBuilder(TestJob::class, JOB_TEST)
             .setInitialDelay(DEFAULT_IMMEDIATE_JOB_DELAY_SEC, TimeUnit.SECONDS)

src/main/java/com/nextcloud/client/jobs/NotificationWork.kt

@@ -88,7 +88,7 @@ class NotificationWork constructor(
         private const val NUMERIC_NOTIFICATION_ID = "NUMERIC_NOTIFICATION_ID"
     }
 
-    @Suppress("TooGenericExceptionCaught") // legacy code
+    @Suppress("TooGenericExceptionCaught", "NestedBlockDepth", "ComplexMethod", "LongMethod") // legacy code
     override fun doWork(): Result {
         val subject = inputData.getString(KEY_NOTIFICATION_SUBJECT) ?: ""
         val signature = inputData.getString(KEY_NOTIFICATION_SIGNATURE) ?: ""

src/main/java/com/owncloud/android/MainApp.java

@@ -40,7 +40,6 @@ import android.os.StrictMode;
 import android.text.TextUtils;
 import android.view.WindowManager;
 
-import com.evernote.android.job.JobManager;
 import com.nextcloud.client.account.User;
 import com.nextcloud.client.account.UserAccountManager;
 import com.nextcloud.client.appinfo.AppInfo;
@@ -69,7 +68,6 @@ import com.owncloud.android.datamodel.ThumbnailsCacheManager;
 import com.owncloud.android.datamodel.UploadsStorageManager;
 import com.owncloud.android.datastorage.DataStorageProvider;
 import com.owncloud.android.datastorage.StoragePoint;
-import com.owncloud.android.jobs.NCJobCreator;
 import com.owncloud.android.lib.common.OwnCloudClientManagerFactory;
 import com.owncloud.android.lib.common.utils.Log_OC;
 import com.owncloud.android.lib.resources.status.OwnCloudVersion;
@@ -257,16 +255,6 @@ public class MainApp extends MultiDexApplication implements HasAndroidInjector {
         int startedMigrationsCount = migrationsManager.startMigration();
         logger.i(TAG, String.format(Locale.US, "Started %d migrations", startedMigrationsCount));
 
-        JobManager.create(this).addJobCreator(
-            new NCJobCreator(
-                accountManager,
-                uploadsStorageManager,
-                clock,
-                eventBus,
-                backgroundJobManager
-            )
-        );
-
         new SecurityUtils();
         DisplayUtils.useCompatVectorIfNeeded();
 

src/main/java/com/owncloud/android/jobs/AccountRemovalJob.java

@@ -1,239 +0,0 @@
-/*
- * Nextcloud Android client application
- *
- * @author Tobias Kaminsky
- * @author Chris Narkiewicz
- *
- * Copyright (C) 2017 Tobias Kaminsky
- * Copyright (C) 2017 Nextcloud GmbH.
- * Copyright (C) 2020 Chris Narkiewicz <hello@ezaquarii.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-package com.owncloud.android.jobs;
-
-import android.accounts.Account;
-import android.accounts.AccountManager;
-import android.content.Context;
-import android.net.Uri;
-import android.os.Build;
-import android.provider.DocumentsContract;
-import android.text.TextUtils;
-
-import com.evernote.android.job.Job;
-import com.evernote.android.job.util.support.PersistableBundleCompat;
-import com.google.gson.Gson;
-import com.nextcloud.client.account.User;
-import com.nextcloud.client.account.UserAccountManager;
-import com.nextcloud.client.core.Clock;
-import com.nextcloud.client.jobs.BackgroundJobManager;
-import com.nextcloud.client.preferences.AppPreferencesImpl;
-import com.nextcloud.java.util.Optional;
-import com.owncloud.android.MainApp;
-import com.owncloud.android.R;
-import com.owncloud.android.datamodel.ArbitraryDataProvider;
-import com.owncloud.android.datamodel.FileDataStorageManager;
-import com.owncloud.android.datamodel.FilesystemDataProvider;
-import com.owncloud.android.datamodel.PushConfigurationState;
-import com.owncloud.android.datamodel.SyncedFolder;
-import com.owncloud.android.datamodel.SyncedFolderProvider;
-import com.owncloud.android.datamodel.UploadsStorageManager;
-import com.owncloud.android.lib.common.OwnCloudClient;
-import com.owncloud.android.lib.common.OwnCloudClientManager;
-import com.owncloud.android.lib.common.OwnCloudClientManagerFactory;
-import com.owncloud.android.lib.common.utils.Log_OC;
-import com.owncloud.android.lib.resources.users.RemoteWipeSuccessRemoteOperation;
-import com.owncloud.android.ui.activity.ContactsPreferenceActivity;
-import com.owncloud.android.ui.events.AccountRemovedEvent;
-import com.owncloud.android.utils.EncryptionUtils;
-import com.owncloud.android.utils.FileStorageUtils;
-import com.owncloud.android.utils.PushUtils;
-
-import org.greenrobot.eventbus.EventBus;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.List;
-
-import androidx.annotation.NonNull;
-
-import static android.content.Context.ACCOUNT_SERVICE;
-import static com.owncloud.android.ui.activity.ManageAccountsActivity.PENDING_FOR_REMOVAL;
-
-/**
- * Removes account and all local files
- */
-public class AccountRemovalJob extends Job {
-    public static final String TAG = "AccountRemovalJob";
-    public static final String ACCOUNT = "account";
-    public static final String REMOTE_WIPE = "remote_wipe";
-
-    private final UploadsStorageManager uploadsStorageManager;
-    private final UserAccountManager userAccountManager;
-    private final BackgroundJobManager backgroundJobManager;
-    private final Clock clock;
-    private final EventBus eventBus;
-
-    public AccountRemovalJob(UploadsStorageManager uploadStorageManager,
-                             UserAccountManager accountManager,
-                             BackgroundJobManager backgroundJobManager,
-                             Clock clock,
-                             EventBus eventBus) {
-        this.uploadsStorageManager = uploadStorageManager;
-        this.userAccountManager = accountManager;
-        this.backgroundJobManager = backgroundJobManager;
-        this.clock = clock;
-        this.eventBus = eventBus;
-    }
-
-    @NonNull
-    @Override
-    protected Result onRunJob(@NonNull Params params) {
-        Context context = MainApp.getAppContext();
-        PersistableBundleCompat bundle = params.getExtras();
-        String accountName = bundle.getString(ACCOUNT, "");
-        if (TextUtils.isEmpty(accountName)) {
-            // didn't receive account to delete
-            return Result.FAILURE;
-        }
-        Optional<User> optionalUser = userAccountManager.getUser(accountName);
-        if (!optionalUser.isPresent()) {
-            // trying to delete non-existing user
-            return Result.FAILURE;
-        }
-        AccountManager accountManager = (AccountManager) context.getSystemService(ACCOUNT_SERVICE);
-        if (accountManager == null) {
-            return Result.FAILURE;
-        }
-        boolean remoteWipe = bundle.getBoolean(REMOTE_WIPE, false);
-
-        ArbitraryDataProvider arbitraryDataProvider = new ArbitraryDataProvider(context.getContentResolver());
-
-        User user = optionalUser.get();
-        backgroundJobManager.cancelPeriodicContactsBackup(user);
-
-        final boolean userRemoved = userAccountManager.removeUser(user);
-        if (userRemoved) {
-            eventBus.post(new AccountRemovedEvent());
-        }
-
-        FileDataStorageManager storageManager = new FileDataStorageManager(user.toPlatformAccount(), context.getContentResolver());
-
-        // remove all files
-        removeFiles(user, storageManager);
-
-        // delete all database entries
-        storageManager.deleteAllFiles();
-
-        // disable daily backup
-        arbitraryDataProvider.storeOrUpdateKeyValue(user.getAccountName(),
-                                                    ContactsPreferenceActivity.PREFERENCE_CONTACTS_AUTOMATIC_BACKUP,
-                                                    "false");
-
-        // unregister push notifications
-        unregisterPushNotifications(context, user, arbitraryDataProvider);
-
-        // remove pending account removal
-        arbitraryDataProvider.deleteKeyForAccount(user.getAccountName(), PENDING_FOR_REMOVAL);
-
-        // remove synced folders set for account
-        remoceSyncedFolders(context, user.toPlatformAccount(), clock);
-
-        // delete all uploads for account
-        uploadsStorageManager.removeAccountUploads(user.toPlatformAccount());
-
-        // delete stored E2E keys
-        arbitraryDataProvider.deleteKeyForAccount(user.getAccountName(), EncryptionUtils.PRIVATE_KEY);
-        arbitraryDataProvider.deleteKeyForAccount(user.getAccountName(), EncryptionUtils.PUBLIC_KEY);
-
-        if (remoteWipe) {
-            Optional<OwnCloudClient> optionalClient = createClient(user);
-            if (optionalClient.isPresent()) {
-                OwnCloudClient client = optionalClient.get();
-                String authToken = client.getCredentials().getAuthToken();
-                new RemoteWipeSuccessRemoteOperation(authToken).execute(client);
-            }
-        }
-
-        // notify Document Provider
-        if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
-            String authority = context.getResources().getString(R.string.document_provider_authority);
-            Uri rootsUri = DocumentsContract.buildRootsUri(authority);
-            context.getContentResolver().notifyChange(rootsUri, null);
-        }
-
-        return Result.SUCCESS;
-    }
-
-    private void unregisterPushNotifications(Context context,
-                                             User user,
-                                             ArbitraryDataProvider arbitraryDataProvider) {
-        final String arbitraryDataPushString = arbitraryDataProvider.getValue(user.toPlatformAccount(),
-                                                                              PushUtils.KEY_PUSH);
-        final String pushServerUrl = context.getResources().getString(R.string.push_server_url);
-        if (!TextUtils.isEmpty(arbitraryDataPushString) && !TextUtils.isEmpty(pushServerUrl)) {
-            Gson gson = new Gson();
-            PushConfigurationState pushArbitraryData = gson.fromJson(arbitraryDataPushString,
-                                                                     PushConfigurationState.class);
-            pushArbitraryData.setShouldBeDeleted(true);
-            arbitraryDataProvider.storeOrUpdateKeyValue(user.getAccountName(), PushUtils.KEY_PUSH,
-                                                        gson.toJson(pushArbitraryData));
-
-            PushUtils.pushRegistrationToServer(userAccountManager, pushArbitraryData.getPushToken());
-        }
-    }
-
-    private void remoceSyncedFolders(Context context, Account account, Clock clock) {
-        SyncedFolderProvider syncedFolderProvider = new SyncedFolderProvider(context.getContentResolver(),
-                                                                             AppPreferencesImpl.fromContext(context),
-                                                                             clock);
-        List<SyncedFolder> syncedFolders = syncedFolderProvider.getSyncedFolders();
-
-        List<Long> syncedFolderIds = new ArrayList<>();
-
-        for (SyncedFolder syncedFolder : syncedFolders) {
-            if (syncedFolder.getAccount().equals(account.name)) {
-                syncedFolderIds.add(syncedFolder.getId());
-            }
-        }
-
-        syncedFolderProvider.deleteSyncFoldersForAccount(account);
-
-        FilesystemDataProvider filesystemDataProvider = new FilesystemDataProvider(context.getContentResolver());
-
-        for (long syncedFolderId : syncedFolderIds) {
-            filesystemDataProvider.deleteAllEntriesForSyncedFolder(Long.toString(syncedFolderId));
-        }
-    }
-
-    private void removeFiles(User user, FileDataStorageManager storageManager) {
-        File tempDir = new File(FileStorageUtils.getTemporalPath(user.getAccountName()));
-        File saveDir = new File(FileStorageUtils.getSavePath(user.getAccountName()));
-
-        FileStorageUtils.deleteRecursively(tempDir, storageManager);
-        FileStorageUtils.deleteRecursively(saveDir, storageManager);
-    }
-
-    private Optional<OwnCloudClient> createClient(User user) {
-        try {
-            Context context = MainApp.getAppContext();
-            OwnCloudClientManager factory = OwnCloudClientManagerFactory.getDefaultSingleton();
-            OwnCloudClient client = factory.getClientFor(user.toOwnCloudAccount(), context);
-            return Optional.of(client);
-        } catch (Exception e) {
-            Log_OC.e(this, "Could not create client", e);
-            return Optional.empty();
-        }
-    }
-}

src/main/java/com/owncloud/android/jobs/NCJobCreator.java

@@ -1,79 +0,0 @@
-/*
- * Nextcloud Android client application
- *
- * @author Mario Danic
- * @author Chris Narkiewicz
- *
- * Copyright (C) 2017 Mario Danic
- * Copyright (C) 2017 Nextcloud GmbH
- * Copyright (C) 2020 Chris Narkiewicz <hello@ezaquarii.com>
- *
- * <p>
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Affero General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * at your option) any later version.
- * <p>
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Affero General Public License for more details.
- * <p>
- * You should have received a copy of the GNU Affero General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-package com.owncloud.android.jobs;
-
-import android.content.Context;
-import android.text.TextUtils;
-
-import com.evernote.android.job.Job;
-import com.evernote.android.job.JobCreator;
-import com.nextcloud.client.account.UserAccountManager;
-import com.nextcloud.client.core.Clock;
-import com.nextcloud.client.jobs.BackgroundJobManager;
-import com.owncloud.android.datamodel.UploadsStorageManager;
-
-import org.greenrobot.eventbus.EventBus;
-
-import androidx.annotation.NonNull;
-
-/**
- * Job creator for android-job
- */
-
-public class NCJobCreator implements JobCreator {
-
-    private final UserAccountManager accountManager;
-    private final UploadsStorageManager uploadsStorageManager;
-    private final Clock clock;
-    private final EventBus eventBus;
-    private final BackgroundJobManager backgroundJobManager;
-
-    public NCJobCreator(
-        UserAccountManager accountManager,
-        UploadsStorageManager uploadsStorageManager,
-        Clock clock,
-        EventBus eventBus,
-        BackgroundJobManager backgroundJobManager
-    ) {
-        this.accountManager = accountManager;
-        this.uploadsStorageManager = uploadsStorageManager;
-        this.clock = clock;
-        this.eventBus = eventBus;
-        this.backgroundJobManager = backgroundJobManager;
-    }
-
-    @Override
-    public Job create(@NonNull String tag) {
-        if (TextUtils.equals(tag, AccountRemovalJob.TAG)) {
-            return new AccountRemovalJob(uploadsStorageManager,
-                                         accountManager,
-                                         backgroundJobManager,
-                                         clock,
-                                         eventBus);
-        } else {
-            return null;
-        }
-    }
-}

src/main/java/com/owncloud/android/jobs/NotificationJob.java

@@ -1,383 +0,0 @@
-/*
- * Nextcloud application
- *
- * @author Mario Danic
- * @author Chris Narkiewicz
- * Copyright (C) 2017-2018 Mario Danic <mario@lovelyhq.com>
- * Copyright (C) 2019 Chris Narkiewicz <hello@ezaquarii.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.owncloud.android.jobs;
-
-import android.accounts.AuthenticatorException;
-import android.accounts.OperationCanceledException;
-import android.app.Activity;
-import android.app.NotificationManager;
-import android.app.PendingIntent;
-import android.content.BroadcastReceiver;
-import android.content.Context;
-import android.content.Intent;
-import android.graphics.BitmapFactory;
-import android.media.RingtoneManager;
-import android.os.Build;
-import android.service.notification.StatusBarNotification;
-import android.text.TextUtils;
-import android.util.Base64;
-import android.util.Log;
-
-import com.evernote.android.job.Job;
-import com.evernote.android.job.util.support.PersistableBundleCompat;
-import com.google.gson.Gson;
-import com.nextcloud.client.account.User;
-import com.nextcloud.client.account.UserAccountManager;
-import com.nextcloud.java.util.Optional;
-import com.owncloud.android.R;
-import com.owncloud.android.datamodel.DecryptedPushMessage;
-import com.owncloud.android.datamodel.SignatureVerification;
-import com.owncloud.android.lib.common.OwnCloudClient;
-import com.owncloud.android.lib.common.OwnCloudClientManagerFactory;
-import com.owncloud.android.lib.common.operations.RemoteOperation;
-import com.owncloud.android.lib.common.operations.RemoteOperationResult;
-import com.owncloud.android.lib.common.utils.Log_OC;
-import com.owncloud.android.lib.resources.notifications.DeleteNotificationRemoteOperation;
-import com.owncloud.android.lib.resources.notifications.GetNotificationRemoteOperation;
-import com.owncloud.android.lib.resources.notifications.models.Action;
-import com.owncloud.android.lib.resources.notifications.models.Notification;
-import com.owncloud.android.lib.resources.notifications.models.RichObject;
-import com.owncloud.android.ui.activity.FileDisplayActivity;
-import com.owncloud.android.ui.activity.NotificationsActivity;
-import com.owncloud.android.ui.notifications.NotificationUtils;
-import com.owncloud.android.utils.PushUtils;
-import com.owncloud.android.utils.ThemeUtils;
-
-import org.apache.commons.httpclient.HttpMethod;
-import org.apache.commons.httpclient.HttpStatus;
-import org.apache.commons.httpclient.methods.DeleteMethod;
-import org.apache.commons.httpclient.methods.GetMethod;
-import org.apache.commons.httpclient.methods.PutMethod;
-import org.apache.commons.httpclient.methods.Utf8PostMethod;
-
-import java.io.IOException;
-import java.security.InvalidKeyException;
-import java.security.NoSuchAlgorithmException;
-import java.security.PrivateKey;
-import java.security.SecureRandom;
-
-import javax.crypto.Cipher;
-import javax.crypto.NoSuchPaddingException;
-import javax.inject.Inject;
-
-import androidx.annotation.NonNull;
-import androidx.core.app.NotificationCompat;
-import androidx.core.app.NotificationManagerCompat;
-import dagger.android.AndroidInjection;
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-
-public class NotificationJob extends Job {
-    public static final String TAG = "NotificationJob";
-
-    public static final String KEY_NOTIFICATION_ACCOUNT = "KEY_NOTIFICATION_ACCOUNT";
-    public static final String KEY_NOTIFICATION_SUBJECT = "subject";
-    public static final String KEY_NOTIFICATION_SIGNATURE = "signature";
-    private static final String KEY_NOTIFICATION_ACTION_LINK = "KEY_NOTIFICATION_ACTION_LINK";
-    private static final String KEY_NOTIFICATION_ACTION_TYPE = "KEY_NOTIFICATION_ACTION_TYPE";
-    private static final String PUSH_NOTIFICATION_ID = "PUSH_NOTIFICATION_ID";
-    private static final String NUMERIC_NOTIFICATION_ID = "NUMERIC_NOTIFICATION_ID";
-
-    private Context context;
-    private UserAccountManager accountManager;
-
-    NotificationJob(final Context context, final UserAccountManager accountManager) {
-        this.context = context;
-        this.accountManager = accountManager;
-    }
-
-    @NonNull
-    @Override
-    protected Result onRunJob(@NonNull Params params) {
-        context = getContext();
-        NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);
-        PersistableBundleCompat persistableBundleCompat = getParams().getExtras();
-        String subject = persistableBundleCompat.getString(KEY_NOTIFICATION_SUBJECT, "");
-        String signature = persistableBundleCompat.getString(KEY_NOTIFICATION_SIGNATURE, "");
-
-        if (!TextUtils.isEmpty(subject) && !TextUtils.isEmpty(signature)) {
-            try {
-                byte[] base64DecodedSubject = Base64.decode(subject, Base64.DEFAULT);
-                byte[] base64DecodedSignature = Base64.decode(signature, Base64.DEFAULT);
-                PrivateKey privateKey = (PrivateKey) PushUtils.readKeyFromFile(false);
-
-                try {
-                    SignatureVerification signatureVerification = PushUtils.verifySignature(context,
-                                                                                            accountManager,
-                                                                                            base64DecodedSignature,
-                                                                                            base64DecodedSubject);
-
-                    if (signatureVerification != null && signatureVerification.isSignatureValid()) {
-                        Cipher cipher = Cipher.getInstance("RSA/None/PKCS1Padding");
-                        cipher.init(Cipher.DECRYPT_MODE, privateKey);
-                        byte[] decryptedSubject = cipher.doFinal(base64DecodedSubject);
-
-                        Gson gson = new Gson();
-                        DecryptedPushMessage decryptedPushMessage = gson.fromJson(new String(decryptedSubject),
-                                                                                  DecryptedPushMessage.class);
-
-                        if (decryptedPushMessage.delete) {
-                            notificationManager.cancel(decryptedPushMessage.nid);
-                        } else if (decryptedPushMessage.deleteAll) {
-                            notificationManager.cancelAll();
-                        } else {
-                            final User user = accountManager.getUser(signatureVerification.getAccount().name)
-                                    .orElseThrow(RuntimeException::new);
-                            fetchCompleteNotification(user, decryptedPushMessage);
-                        }
-                    }
-                } catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException e1) {
-                    Log.d(TAG, "Error decrypting message " + e1.getClass().getName()
-                        + " " + e1.getLocalizedMessage());
-                }
-            } catch (Exception exception) {
-                Log.d(TAG, "Something went very wrong" + exception.getLocalizedMessage());
-            }
-        }
-        return Result.SUCCESS;
-    }
-
-    private void sendNotification(Notification notification, User user) {
-        SecureRandom randomId = new SecureRandom();
-        RichObject file = notification.subjectRichParameters.get("file");
-
-        Intent intent;
-        if (file == null) {
-            intent = new Intent(context, NotificationsActivity.class);
-        } else {
-            intent = new Intent(context, FileDisplayActivity.class);
-            intent.setAction(Intent.ACTION_VIEW);
-            intent.putExtra(FileDisplayActivity.KEY_FILE_ID, file.id);
-        }
-        intent.putExtra(KEY_NOTIFICATION_ACCOUNT, user.getAccountName());
-        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
-
-        PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_ONE_SHOT);
-        int pushNotificationId = randomId.nextInt();
-
-        NotificationCompat.Builder notificationBuilder =
-            new NotificationCompat.Builder(context, NotificationUtils.NOTIFICATION_CHANNEL_PUSH)
-                .setSmallIcon(R.drawable.notification_icon)
-                .setLargeIcon(BitmapFactory.decodeResource(context.getResources(), R.drawable.notification_icon))
-                .setColor(ThemeUtils.primaryColor(user.toPlatformAccount(), false, context))
-                .setShowWhen(true)
-                .setSubText(user.getAccountName())
-                .setContentTitle(notification.getSubject())
-                .setContentText(notification.getMessage())
-                .setSound(RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION))
-                .setAutoCancel(true)
-                .setVisibility(NotificationCompat.VISIBILITY_PRIVATE)
-                .setContentIntent(pendingIntent);
-
-        // Remove
-        if (notification.getActions().isEmpty()) {
-            Intent disableDetection = new Intent(context, NotificationJob.NotificationReceiver.class);
-            disableDetection.putExtra(NUMERIC_NOTIFICATION_ID, notification.getNotificationId());
-            disableDetection.putExtra(PUSH_NOTIFICATION_ID, pushNotificationId);
-            disableDetection.putExtra(KEY_NOTIFICATION_ACCOUNT, user.getAccountName());
-
-            PendingIntent disableIntent = PendingIntent.getBroadcast(context, pushNotificationId, disableDetection,
-                                                                     PendingIntent.FLAG_CANCEL_CURRENT);
-
-            notificationBuilder.addAction(new NotificationCompat.Action(R.drawable.ic_close,
-                                                                        context.getString(R.string.remove_push_notification), disableIntent));
-        } else {
-            // Actions
-            for (Action action : notification.getActions()) {
-                Intent actionIntent = new Intent(context, NotificationJob.NotificationReceiver.class);
-                actionIntent.putExtra(NUMERIC_NOTIFICATION_ID, notification.getNotificationId());
-                actionIntent.putExtra(PUSH_NOTIFICATION_ID, pushNotificationId);
-                actionIntent.putExtra(KEY_NOTIFICATION_ACCOUNT, user.getAccountName());
-                actionIntent.putExtra(KEY_NOTIFICATION_ACTION_LINK, action.link);
-                actionIntent.putExtra(KEY_NOTIFICATION_ACTION_TYPE, action.type);
-
-
-                PendingIntent actionPendingIntent = PendingIntent.getBroadcast(context, randomId.nextInt(),
-                                                                               actionIntent,
-                                                                               PendingIntent.FLAG_CANCEL_CURRENT);
-
-                int icon;
-                if (action.primary) {
-                    icon = R.drawable.ic_check_circle;
-                } else {
-                    icon = R.drawable.ic_check_circle_outline;
-                }
-
-                notificationBuilder.addAction(new NotificationCompat.Action(icon, action.label, actionPendingIntent));
-            }
-        }
-
-        notificationBuilder.setPublicVersion(
-            new NotificationCompat.Builder(context, NotificationUtils.NOTIFICATION_CHANNEL_PUSH)
-                .setSmallIcon(R.drawable.notification_icon)
-                .setLargeIcon(BitmapFactory.decodeResource(context.getResources(), R.drawable.notification_icon))
-                .setColor(ThemeUtils.primaryColor(user.toPlatformAccount(), false, context))
-                .setShowWhen(true)
-                .setSubText(user.getAccountName())
-                .setContentTitle(context.getString(R.string.new_notification))
-                .setSound(RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION))
-                .setAutoCancel(true)
-                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-                .setContentIntent(pendingIntent).build());
-
-        NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);
-        notificationManager.notify(notification.getNotificationId(), notificationBuilder.build());
-    }
-
-    private void fetchCompleteNotification(User account, DecryptedPushMessage decryptedPushMessage) {
-        Optional<User> optionalUser = accountManager.getUser(account.getAccountName());
-
-        if (!optionalUser.isPresent()) {
-            Log_OC.e(this, "Account may not be null");
-            return;
-        }
-        User user = optionalUser.get();
-
-        try {
-            OwnCloudClient client = OwnCloudClientManagerFactory.getDefaultSingleton()
-                .getClientFor(user.toOwnCloudAccount(), context);
-
-            RemoteOperationResult result = new GetNotificationRemoteOperation(decryptedPushMessage.nid)
-                .execute(client);
-
-            if (result.isSuccess()) {
-                Notification notification = result.getNotificationData().get(0);
-                sendNotification(notification, account);
-            }
-
-        } catch (Exception e) {
-            Log_OC.e(this, "Error creating account", e);
-        }
-    }
-
-    public static class NotificationReceiver extends BroadcastReceiver {
-
-        @Inject UserAccountManager accountManager;
-
-        @Override
-        public void onReceive(Context context, Intent intent) {
-            AndroidInjection.inject(this, context);
-            int numericNotificationId = intent.getIntExtra(NUMERIC_NOTIFICATION_ID, 0);
-            String accountName = intent.getStringExtra(NotificationJob.KEY_NOTIFICATION_ACCOUNT);
-
-            if (numericNotificationId != 0) {
-                new Thread(() -> {
-                    NotificationManager notificationManager = (NotificationManager) context.getSystemService(
-                        Activity.NOTIFICATION_SERVICE);
-
-                    android.app.Notification oldNotification = null;
-                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && notificationManager != null) {
-                        for (StatusBarNotification statusBarNotification : notificationManager.getActiveNotifications()) {
-                            if (numericNotificationId == statusBarNotification.getId()) {
-                                oldNotification = statusBarNotification.getNotification();
-                                break;
-                            }
-                        }
-
-                        cancel(context, numericNotificationId);
-                    }
-
-                    try {
-                        Optional<User> optionalUser = accountManager.getUser(accountName);
-                        if (!optionalUser.isPresent()) {
-                            Log_OC.e(this, "Account may not be null");
-                            return;
-                        }
-                        User user = optionalUser.get();
-                        OwnCloudClient client = OwnCloudClientManagerFactory.getDefaultSingleton()
-                            .getClientFor(user.toOwnCloudAccount(), context);
-
-                        String actionType = intent.getStringExtra(KEY_NOTIFICATION_ACTION_TYPE);
-                        String actionLink = intent.getStringExtra(KEY_NOTIFICATION_ACTION_LINK);
-
-                        boolean success;
-                        if (!TextUtils.isEmpty(actionType) && !TextUtils.isEmpty(actionLink)) {
-                            int resultCode = executeAction(actionType, actionLink, client);
-                            success = resultCode == HttpStatus.SC_OK || resultCode == HttpStatus.SC_ACCEPTED;
-                        } else {
-                            success = new DeleteNotificationRemoteOperation(numericNotificationId)
-                                .execute(client).isSuccess();
-                        }
-
-                        if (success) {
-                            if (oldNotification == null) {
-                                cancel(context, numericNotificationId);
-                            }
-                        } else if (notificationManager != null) {
-                            notificationManager.notify(numericNotificationId, oldNotification);
-                        }
-                    } catch (IOException | OperationCanceledException | AuthenticatorException e) {
-                        Log_OC.e(TAG, "Error initializing client", e);
-                    }
-                }).start();
-            }
-        }
-
-        @SuppressFBWarnings(value = "HTTP_PARAMETER_POLLUTION",
-            justification = "link and type are from server and expected to be safe")
-        private int executeAction(String actionType, String actionLink, OwnCloudClient client) {
-            HttpMethod method;
-
-            switch (actionType) {
-                case "GET":
-                    method = new GetMethod(actionLink);
-                    break;
-
-                case "POST":
-                    method = new Utf8PostMethod(actionLink);
-                    break;
-
-                case "DELETE":
-                    method = new DeleteMethod(actionLink);
-                    break;
-
-                case "PUT":
-                    method = new PutMethod(actionLink);
-                    break;
-
-                default:
-                    // do nothing
-                    return 0;
-            }
-
-            method.setRequestHeader(RemoteOperation.OCS_API_HEADER, RemoteOperation.OCS_API_HEADER_VALUE);
-
-            try {
-                return client.executeMethod(method);
-            } catch (IOException e) {
-                Log_OC.e(TAG, "Execution of notification action failed: " + e);
-            } finally {
-                method.releaseConnection();
-            }
-            return 0;
-        }
-
-        private void cancel(Context context, int notificationId) {
-            NotificationManager notificationManager = (NotificationManager) context.getSystemService(
-                Activity.NOTIFICATION_SERVICE);
-
-            if (notificationManager != null) {
-                notificationManager.cancel(notificationId);
-            }
-        }
-    }
-}

src/main/java/com/owncloud/android/ui/activity/FileActivity.java

@@ -40,6 +40,7 @@ import android.view.View;
 
 import com.google.android.material.snackbar.Snackbar;
 import com.nextcloud.client.account.UserAccountManager;
+import com.nextcloud.client.jobs.BackgroundJobManager;
 import com.nextcloud.client.network.ConnectivityService;
 import com.owncloud.android.MainApp;
 import com.owncloud.android.R;
@@ -151,6 +152,9 @@ public abstract class FileActivity extends DrawerActivity
     @Inject
     ConnectivityService connectivityService;
 
+    @Inject
+    BackgroundJobManager backgroundJobManager;
+
     @Override
     public void showFiles(boolean onDeviceOnly) {
         // must be specialized in subclasses
@@ -405,7 +409,7 @@ public abstract class FileActivity extends DrawerActivity
         boolean remoteWipeSupported = accountManager.getServerVersion(account).isRemoteWipeSupported();
 
         if (remoteWipeSupported) {
-            new CheckRemoteWipeTask(account, new WeakReference<>(this)).execute();
+            new CheckRemoteWipeTask(backgroundJobManager, account, new WeakReference<>(this)).execute();
         } else {
             performCredentialsUpdate(account, context);
         }

src/main/java/com/owncloud/android/ui/activity/ManageAccountsActivity.java

@@ -38,10 +38,9 @@ import android.os.Handler;
 import android.os.IBinder;
 import android.view.MenuItem;
 
-import com.evernote.android.job.JobRequest;
-import com.evernote.android.job.util.support.PersistableBundleCompat;
 import com.nextcloud.client.account.User;
 import com.nextcloud.client.account.UserAccountManager;
+import com.nextcloud.client.jobs.BackgroundJobManager;
 import com.nextcloud.client.onboarding.FirstRunActivity;
 import com.nextcloud.java.util.Optional;
 import com.owncloud.android.MainApp;
@@ -50,7 +49,6 @@ import com.owncloud.android.datamodel.ArbitraryDataProvider;
 import com.owncloud.android.datamodel.FileDataStorageManager;
 import com.owncloud.android.files.services.FileDownloader;
 import com.owncloud.android.files.services.FileUploader;
-import com.owncloud.android.jobs.AccountRemovalJob;
 import com.owncloud.android.lib.common.OwnCloudAccount;
 import com.owncloud.android.lib.common.utils.Log_OC;
 import com.owncloud.android.services.OperationsService;
@@ -111,6 +109,7 @@ public class ManageAccountsActivity extends FileActivity implements UserListAdap
     private ArbitraryDataProvider arbitraryDataProvider;
     private boolean multipleAccountsSupported;
 
+    @Inject BackgroundJobManager backgroundJobManager;
     @Inject UserAccountManager accountManager;
 
     @Override
@@ -431,16 +430,7 @@ public class ManageAccountsActivity extends FileActivity implements UserListAdap
             mDownloaderBinder.cancel(user.toPlatformAccount());
         }
 
-        // schedule job
-        PersistableBundleCompat bundle = new PersistableBundleCompat();
-        bundle.putString(AccountRemovalJob.ACCOUNT, user.getAccountName());
-
-        new JobRequest.Builder(AccountRemovalJob.TAG)
-                .startNow()
-                .setExtras(bundle)
-                .setUpdateCurrent(false)
-                .build()
-                .schedule();
+        backgroundJobManager.startAccountRemovalJob(user.getAccountName(), false);
 
         // immediately select a new account
         List<User> users = accountManager.getAllUsers();

src/main/java/com/owncloud/android/ui/activity/UserInfoActivity.java

@@ -50,13 +50,11 @@ import android.widget.TextView;
 import com.bumptech.glide.Glide;
 import com.bumptech.glide.request.animation.GlideAnimation;
 import com.bumptech.glide.request.target.SimpleTarget;
-import com.evernote.android.job.JobRequest;
-import com.evernote.android.job.util.support.PersistableBundleCompat;
 import com.nextcloud.client.account.User;
 import com.nextcloud.client.di.Injectable;
+import com.nextcloud.client.jobs.BackgroundJobManager;
 import com.nextcloud.client.preferences.AppPreferences;
 import com.owncloud.android.R;
-import com.owncloud.android.jobs.AccountRemovalJob;
 import com.owncloud.android.lib.common.UserInfo;
 import com.owncloud.android.lib.common.operations.RemoteOperation;
 import com.owncloud.android.lib.common.operations.RemoteOperationResult;
@@ -333,6 +331,7 @@ public class UserInfoActivity extends FileActivity implements Injectable {
 
     public static class AccountRemovalConfirmationDialog extends DialogFragment {
 
+        @Inject BackgroundJobManager backgroundJobManager;
         private Account account;
 
         public static UserInfoActivity.AccountRemovalConfirmationDialog newInstance(User user) {
@@ -373,16 +372,7 @@ public class UserInfoActivity extends FileActivity implements Injectable {
                     .setIcon(R.drawable.ic_warning)
                     .setPositiveButton(R.string.common_ok,
                             (dialogInterface, i) -> {
-                                // schedule job
-                                PersistableBundleCompat bundle = new PersistableBundleCompat();
-                                bundle.putString(AccountRemovalJob.ACCOUNT, account.name);
-
-                                new JobRequest.Builder(AccountRemovalJob.TAG)
-                                    .startNow()
-                                    .setExtras(bundle)
-                                    .setUpdateCurrent(false)
-                                    .build()
-                                    .schedule();
+                                backgroundJobManager.startAccountRemovalJob(account.name, false);
                             })
                     .setNegativeButton(R.string.common_cancel, null)
                     .create();

src/main/java/com/owncloud/android/ui/asynctasks/CheckRemoteWipeTask.java

@@ -26,9 +26,7 @@ package com.owncloud.android.ui.asynctasks;
 import android.accounts.Account;
 import android.os.AsyncTask;
 
-import com.evernote.android.job.JobRequest;
-import com.evernote.android.job.util.support.PersistableBundleCompat;
-import com.owncloud.android.jobs.AccountRemovalJob;
+import com.nextcloud.client.jobs.BackgroundJobManager;
 import com.owncloud.android.lib.common.operations.RemoteOperationResult;
 import com.owncloud.android.lib.common.utils.Log_OC;
 import com.owncloud.android.lib.resources.users.CheckRemoteWipeRemoteOperation;
@@ -37,17 +35,21 @@ import com.owncloud.android.ui.activity.FileActivity;
 import java.lang.ref.WeakReference;
 
 public class CheckRemoteWipeTask extends AsyncTask<Void, Void, Boolean> {
+    private BackgroundJobManager backgroundJobManager;
     private Account account;
     private WeakReference<FileActivity> fileActivityWeakReference;
 
-    public CheckRemoteWipeTask(Account account, WeakReference<FileActivity> fileActivityWeakReference) {
+    public CheckRemoteWipeTask(BackgroundJobManager backgroundJobManager,
+                               Account account,
+                               WeakReference<FileActivity> fileActivityWeakReference) {
+        this.backgroundJobManager = backgroundJobManager;
         this.account = account;
         this.fileActivityWeakReference = fileActivityWeakReference;
     }
 
     @Override
     protected Boolean doInBackground(Void... voids) {
-        FileActivity fileActivity = fileActivityWeakReference.get();
+        final FileActivity fileActivity = fileActivityWeakReference.get();
 
         if (fileActivity == null) {
             Log_OC.e(this, "Check for remote wipe: no context available");
@@ -57,22 +59,10 @@ public class CheckRemoteWipeTask extends AsyncTask<Void, Void, Boolean> {
         RemoteOperationResult checkWipeResult = new CheckRemoteWipeRemoteOperation().execute(account, fileActivity);
 
         if (checkWipeResult.isSuccess()) {
-            // schedule job
-            PersistableBundleCompat bundle = new PersistableBundleCompat();
-            bundle.putString(AccountRemovalJob.ACCOUNT, account.name);
-            bundle.putBoolean(AccountRemovalJob.REMOTE_WIPE, true);
-
-            new JobRequest.Builder(AccountRemovalJob.TAG)
-                .startNow()
-                .setExtras(bundle)
-                .setUpdateCurrent(false)
-                .build()
-                .schedule();
+            backgroundJobManager.startAccountRemovalJob(account.name, true);
         } else {
             Log_OC.e(this, "Check for remote wipe not needed -> update credentials");
-
             fileActivity.performCredentialsUpdate(account, fileActivity);
-
         }
 
         return Boolean.TRUE;