diff --git a/app/src/main/java/org/thoughtcrime/securesms/loki/api/BackgroundPollWorker.kt b/app/src/main/java/org/thoughtcrime/securesms/loki/api/BackgroundPollWorker.kt
index ff673db078..86970cbcdc 100644
--- a/app/src/main/java/org/thoughtcrime/securesms/loki/api/BackgroundPollWorker.kt
+++ b/app/src/main/java/org/thoughtcrime/securesms/loki/api/BackgroundPollWorker.kt
@@ -8,7 +8,6 @@ import nl.komponents.kovenant.Promise
 import nl.komponents.kovenant.all
 import nl.komponents.kovenant.functional.map
 import org.session.libsession.messaging.jobs.MessageReceiveJob
-import org.session.libsession.messaging.open_groups.OpenGroup
 import org.session.libsession.messaging.open_groups.OpenGroupV2
 import org.session.libsession.messaging.sending_receiving.pollers.ClosedGroupPoller
 import org.session.libsession.messaging.sending_receiving.pollers.OpenGroupPoller
@@ -27,26 +26,20 @@ class BackgroundPollWorker(val context: Context, params: WorkerParameters) : Wor
         @JvmStatic
         fun schedulePeriodic(context: Context) {
             Log.v(TAG, "Scheduling periodic work.")
-            val workRequest = PeriodicWorkRequestBuilder<BackgroundPollWorker>(5, TimeUnit.MINUTES)
-                    .setConstraints(Constraints.Builder()
-                            .setRequiredNetworkType(NetworkType.CONNECTED)
-                            .build()
-                    )
-                    .build()
-
-            WorkManager
-                    .getInstance(context)
-                    .enqueueUniquePeriodicWork(
-                            TAG,
-                            ExistingPeriodicWorkPolicy.REPLACE,
-                            workRequest
-                    )
+            val builder = PeriodicWorkRequestBuilder<BackgroundPollWorker>(5, TimeUnit.MINUTES)
+            builder.setConstraints(Constraints.Builder().setRequiredNetworkType(NetworkType.CONNECTED).build())
+            val workRequest = builder.build()
+            WorkManager.getInstance(context).enqueueUniquePeriodicWork(
+                TAG,
+                ExistingPeriodicWorkPolicy.REPLACE,
+                workRequest
+            )
         }
     }
 
     override fun doWork(): Result {
         if (TextSecurePreferences.getLocalNumber(context) == null) {
-            Log.v(TAG, "Background poll is canceled due to the Session user is not set up yet.")
+            Log.v(TAG, "User not registered yet.")
             return Result.failure()
         }
 
@@ -54,37 +47,35 @@ class BackgroundPollWorker(val context: Context, params: WorkerParameters) : Wor
             Log.v(TAG, "Performing background poll.")
             val promises = mutableListOf<Promise<Unit, Exception>>()
 
-            // Private chats
+            // DMs
             val userPublicKey = TextSecurePreferences.getLocalNumber(context)!!
-            val privateChatsPromise = SnodeAPI.getMessages(userPublicKey).map { envelopes ->
+            val dmsPromise = SnodeAPI.getMessages(userPublicKey).map { envelopes ->
                 envelopes.map { envelope ->
                     // FIXME: Using a job here seems like a bad idea...
                     MessageReceiveJob(envelope.toByteArray(), false).executeAsync()
                 }
             }
-            promises.addAll(privateChatsPromise.get())
+            promises.addAll(dmsPromise.get())
 
             // Closed groups
             promises.addAll(ClosedGroupPoller().pollOnce())
 
             // Open Groups
-            val openGroups = DatabaseFactory.getLokiThreadDatabase(context).getAllPublicChats().map { (_,chat)->
-                OpenGroup(chat.channel, chat.server, chat.displayName, chat.isDeletable)
-            }
+            val openGroups = DatabaseFactory.getLokiThreadDatabase(context).getAllPublicChats().values
             for (openGroup in openGroups) {
                 val poller = OpenGroupPoller(openGroup)
                 promises.add(poller.pollForNewMessages())
             }
 
-            val openGroupsV2 = DatabaseFactory.getLokiThreadDatabase(context).getAllV2OpenGroups().values.groupBy(OpenGroupV2::server)
+            val v2OpenGroups = DatabaseFactory.getLokiThreadDatabase(context).getAllV2OpenGroups().values.groupBy(OpenGroupV2::server)
 
-            openGroupsV2.values.map { groups ->
+            v2OpenGroups.values.map { groups ->
                 OpenGroupV2Poller(groups)
             }.forEach { poller ->
-                promises.add(poller.compactPoll(true).map{ /*Unit*/ })
+                promises.add(poller.compactPoll(true).map { })
             }
 
-            // Wait till all the promises get resolved
+            // Wait until all the promises are resolved
             all(promises).get()
 
             return Result.success()