Event Insert and Delete on a background thread for ListActivity

- database insertion and deletion now on a background thread through asynctask - updating the recycler view is managed through LiveData observable Signed-off-by: Arka Prava Basu <[email protected]>
guardianproject · Sep 8, 2018 · 0fe3478 · 0fe3478
1 parent 57da23b
commit 0fe3478
Show file tree

Hide file tree

Showing 6 changed files with 128 additions and 63 deletions.
diff --git a/src/main/java/org/havenapp/main/ListActivity.java b/src/main/java/org/havenapp/main/ListActivity.java
@@ -18,6 +18,7 @@
 package org.havenapp.main;
 
 import android.annotation.SuppressLint;
+import android.arch.lifecycle.LiveData;
 import android.arch.lifecycle.Observer;
 import android.content.Intent;
 import android.database.sqlite.SQLiteException;
@@ -26,7 +27,6 @@
 import android.graphics.drawable.Drawable;
 import android.os.Build;
 import android.os.Bundle;
-import android.os.Handler;
 import android.support.annotation.NonNull;
 import android.support.design.widget.FloatingActionButton;
 import android.support.design.widget.Snackbar;
@@ -48,6 +48,10 @@
 import com.mikepenz.aboutlibraries.LibsBuilder;
 
 import org.havenapp.main.database.HavenEventDB;
+import org.havenapp.main.database.async.EventDeleteAllAsync;
+import org.havenapp.main.database.async.EventDeleteAsync;
+import org.havenapp.main.database.async.EventInsertAllAsync;
+import org.havenapp.main.database.async.EventInsertAsync;
 import org.havenapp.main.model.Event;
 import org.havenapp.main.resources.IResourceManager;
 import org.havenapp.main.resources.ResourceManager;
@@ -76,8 +80,7 @@ public class ListActivity extends AppCompatActivity {
 
     private int REQUEST_CODE_INTRO = 1001;
 
-
-    private Handler handler = new Handler();
+    private LiveData<List<Event>> eventListLD;
 
     private Observer<List<Event>> eventListObserver = events -> {
         if (events != null) {
@@ -153,14 +156,9 @@ public void onSwiped(RecyclerView.ViewHolder viewHolder, int direction) {
         }
 
 
-        fab.setOnClickListener(new View.OnClickListener() {
-            @Override
-            public void onClick(View v) {
-
-                Intent i = new Intent(ListActivity.this, MonitorActivity.class);
-                startActivity(i);
-
-            }
+        fab.setOnClickListener(v -> {
+            Intent i = new Intent(ListActivity.this, MonitorActivity.class);
+            startActivity(i);
         });
 
         if (preferences.isFirstLaunch()) {
@@ -199,8 +197,8 @@ private void setEventListToRecyclerView(@NonNull List<Event> events) {
 
     private void fetchEventList() {
         try {
-            HavenEventDB.getDatabase(this).getEventDAO().getAllEventDesc()
-                    .observe(this, eventListObserver);
+            eventListLD = HavenEventDB.getDatabase(this).getEventDAO().getAllEventDesc();
+            eventListLD.observe(this, eventListObserver);
         } catch (SQLiteException sqe) {
             Log.d(getClass().getName(), "database not yet initiatied", sqe);
         }
@@ -218,33 +216,17 @@ private void showNonEmptyState() {
 
     private void deleteEvent (final Event event, final int position)
     {
-
-        final Runnable runnableDelete = new Runnable ()
-        {
-            public void run ()
-            {
-                HavenEventDB.getDatabase(ListActivity.this).getEventDAO().delete(event);
-            }
-        };
-
-        handler.postDelayed(runnableDelete,5000);
+        new EventDeleteAsync(() -> onEventDeleted(event, position)).execute(event);
         events.remove(position);
         adapter.notifyItemRemoved(position);
+    }
 
-        HavenEventDB.getDatabase(ListActivity.this).getEventDAO().delete(event);
-
+    private void onEventDeleted(Event event, int position) {
         Snackbar.make(recyclerView, resourceManager.getString(R.string.event_deleted), Snackbar.LENGTH_SHORT)
-                .setAction(resourceManager.getString(R.string.undo), new View.OnClickListener() {
-                    @Override
-                    public void onClick(View v) {
-                        handler.removeCallbacks(runnableDelete);
-                        long eventId = HavenEventDB.getDatabase(ListActivity.this)
-                                .getEventDAO().insert(event);
-                        event.setId(eventId);
-                        events.add(position, event);
-                        adapter.notifyItemInserted(position);
-                    }
-                })
+                .setAction(resourceManager.getString(R.string.undo),
+                        v -> new EventInsertAsync(eventId -> {
+                    event.setId(eventId);
+                }).execute(event))
                 .show();
     }
 
@@ -329,36 +311,21 @@ public boolean onOptionsItemSelected (MenuItem item) {
 
     private void removeAllEvents()
     {
-        final List<Event> removedEvents = new ArrayList<Event>();
-        final Runnable runnableDelete = new Runnable ()
-        {
-            public void run ()
-            {
-                for (Event event : removedEvents) {
-                    HavenEventDB.getDatabase(ListActivity.this).getEventDAO().delete(event);
-                }
-            }
-        };
-
-        for (int i = 0, size = events.size(); i < size; i++) {
-            removedEvents.add(events.remove(0));
-            adapter.notifyItemRemoved(0);
-        }
-
-        handler.postDelayed(runnableDelete, 3000);
+        final List<Event> removedEvents = new ArrayList<Event>(events);
+        events.clear();
+        adapter.notifyDataSetChanged();
+        new EventDeleteAllAsync(() -> onAllEventsRemoved(removedEvents)).execute(removedEvents);
+    }
 
+    private void onAllEventsRemoved(List<Event> removedEvents) {
         Snackbar.make(recyclerView, resourceManager.getString(R.string.events_deleted), Snackbar.LENGTH_SHORT)
-                .setAction(resourceManager.getString(R.string.undo), v -> {
-                    handler.removeCallbacks(runnableDelete);
-
-                        for (Event event : removedEvents) {
-                            long eventId = HavenEventDB.getDatabase(ListActivity.this)
-                                    .getEventDAO().insert(event);
-                            event.setId(eventId);
-                            events.add(event);
-                            adapter.notifyItemInserted(events.size() - 1);
-                        }
+                .setAction(resourceManager.getString(R.string.undo),
+                        v -> new EventInsertAllAsync(eventIdList -> {
+                    for (int i = 0; i < removedEvents.size(); i++) {
+                        Event event = removedEvents.get(i);
+                        event.setId(eventIdList.get(i));
                     }
+                }).execute(removedEvents)
                 )
                 .show();
     }

diff --git a/src/main/java/org/havenapp/main/dao/EventDAO.kt b/src/main/java/org/havenapp/main/dao/EventDAO.kt
@@ -13,9 +13,15 @@ interface EventDAO {
     @Insert
     fun insert(event: Event): Long
 
+    @Insert
+    fun insertAll(eventList: List<Event>): List<Long>
+
     @Delete
     fun delete(event: Event)
 
+    @Delete
+    fun deleteAll(eventList: List<Event>)
+
     @Update
     fun update(event: Event)
 

diff --git a/src/main/java/org/havenapp/main/database/async/EventDeleteAllAsync.kt b/src/main/java/org/havenapp/main/database/async/EventDeleteAllAsync.kt
@@ -0,0 +1,23 @@
+package org.havenapp.main.database.async
+
+import android.os.AsyncTask
+import org.havenapp.main.HavenApp
+import org.havenapp.main.model.Event
+
+/**
+ * Created by Arka Prava Basu <[email protected]> on 6/9/18.
+ */
+class EventDeleteAllAsync(private val listener: EventDeleteAllListener)
+    : AsyncTask<List<Event>, Unit, Unit>() {
+    override fun doInBackground(vararg params: List<Event>) {
+        HavenApp.dataBaseInstance.getEventDAO().deleteAll(params.get(0))
+    }
+
+    override fun onPostExecute(result: Unit?) {
+        listener.onEventsDeleted()
+    }
+
+    interface EventDeleteAllListener {
+        fun onEventsDeleted()
+    }
+}
diff --git a/src/main/java/org/havenapp/main/database/async/EventDeleteAsync.kt b/src/main/java/org/havenapp/main/database/async/EventDeleteAsync.kt
@@ -0,0 +1,23 @@
+package org.havenapp.main.database.async
+
+import android.os.AsyncTask
+import org.havenapp.main.HavenApp
+import org.havenapp.main.model.Event
+
+/**
+ * Created by Arka Prava Basu <[email protected]> on 6/9/18.
+ */
+class EventDeleteAsync(private val listener: EventDeleteListener)
+    : AsyncTask<Event, Unit, Unit>() {
+    override fun doInBackground(vararg params: Event) {
+        HavenApp.dataBaseInstance.getEventDAO().delete(params.get(0))
+    }
+
+    override fun onPostExecute(result: Unit?) {
+        listener.onDeleteEvent()
+    }
+
+    interface EventDeleteListener {
+        fun onDeleteEvent()
+    }
+}
diff --git a/src/main/java/org/havenapp/main/database/async/EventInsertAllAsync.kt b/src/main/java/org/havenapp/main/database/async/EventInsertAllAsync.kt
@@ -0,0 +1,23 @@
+package org.havenapp.main.database.async
+
+import android.os.AsyncTask
+import org.havenapp.main.HavenApp
+import org.havenapp.main.model.Event
+
+/**
+ * Created by Arka Prava Basu <[email protected]> on 6/9/18.
+ */
+class EventInsertAllAsync(private val listener: EventInsertListener)
+    : AsyncTask<List<Event>, Unit, List<Long>>() {
+    override fun doInBackground(vararg params: List<Event>): List<Long> {
+        return HavenApp.dataBaseInstance.getEventDAO().insertAll(params.get(0))
+    }
+
+    override fun onPostExecute(result: List<Long>) {
+        listener.onInsertionComplete(result)
+    }
+
+    interface EventInsertListener {
+        fun onInsertionComplete(eventIdList: List<Long>)
+    }
+}
diff --git a/src/main/java/org/havenapp/main/database/async/EventInsertAsync.kt b/src/main/java/org/havenapp/main/database/async/EventInsertAsync.kt
@@ -0,0 +1,23 @@
+package org.havenapp.main.database.async
+
+import android.os.AsyncTask
+import org.havenapp.main.HavenApp
+import org.havenapp.main.model.Event
+
+/**
+ * Created by Arka Prava Basu <[email protected]> on 6/9/18.
+ */
+class EventInsertAsync(val listener: EventInsertListener): AsyncTask<Event, Unit, Long>() {
+    override fun doInBackground(vararg params: Event): Long {
+        val event = params.get(0)
+        return HavenApp.dataBaseInstance.getEventDAO().insert(event)
+    }
+
+    override fun onPostExecute(result: Long) {
+        listener.onInsertionComplete(result)
+    }
+
+    interface EventInsertListener {
+        fun onInsertionComplete(eventId: Long)
+    }
+}