0

I need to select data from a table, manipulate it and then insert it into another table. This only happens when the app is opened for the first time that day and this isn't going to be used in the UI. I don't want to use LiveData because it doesn't need to be observed but when I was looking into how to do it, most people say I should use LiveData. I've tried using AsyncTask but I get the error "Cannot access database on the main thread since it may potentially....". Here is the code for my AsyncTask

 public class getAllClothesArrayAsyncTask extends AsyncTask<ArrayList<ClothingItem>, Void, ArrayList<ClothingItem>[]> {

        private ClothingDao mAsyncDao;
        getAllClothesArrayAsyncTask(ClothingDao dao) { mAsyncDao = dao;}


        @Override
        protected ArrayList<ClothingItem>[] doInBackground(ArrayList<ClothingItem>... arrayLists) {

            List<ClothingItem> clothingList  = mAsyncDao.getAllClothesArray();
            ArrayList<ClothingItem> arrayList = new ArrayList<>(clothingList);
            return arrayLists;
        }
    }

And this is how I'm calling it in my activity

        mClothingViewModel = new ViewModelProvider(this).get(ClothingViewModel.class);
        clothingItemArray = mClothingViewModel.getClothesArray();

What is the best practice in this situation?

olivia.dayaram
  • 59
  • 12

1 Answers1

0

Brief summary:

  1. Room really doesn't allow to do anything (query|insert|update|delete) on main thread. You can switch off this control on RoomDatabaseBuilder, but you better shouldn't.
  2. If you don't care about UI, minimally you can just to put your ROOM-ish code (Runnable) to one of - Thread, Executor, AsyncTask (but it was deprecated last year)... I've put examples below
  3. Best practices in this one-shot operation to DB I think are Coroutines (for those who use Kotlin at projects) and RxJava (for those who use Java, Single|Maybe as a return types). They give much more possibilities but you should invest your time to get the point of these mechanisms.
  4. To observe data stream from Room there are LiveData, Coroutines Flow, RxJava (Flowable).

Several examples of using Thread-switching with lambdas enabled (if you on some purpose don't want to learn more advanced stuff):

  • Just a Thread

    new Thread(() -> { List<ClothingItem> clothingList = mAsyncDao.getAllClothesArray(); // ... next operations });

  • Executor

    Executors.newSingleThreadExecutor().submit(() -> { List<ClothingItem> clothingList = mAsyncDao.getAllClothesArray(); // ... next operations });

  • AsyncTask

    AsyncTask.execute(() -> { List<ClothingItem> clothingList = mAsyncDao.getAllClothesArray(); // ... next operations });

If you use Repository pattern you can put all this thread-switching there

Another useful link to read about life after AsyncTask deprecation

sergiy tikhonov
  • 4,961
  • 1
  • 10
  • 27
  • 1
    Thank you! I ended up using the AsyncTask after I realized that there was an issue with a different part of my code. I will definitely look into the AsyncTask deprecation link. – olivia.dayaram May 16 '20 at 20:56
  • @sergiy tikhonov I have a similar use case, trying to convert AsyncTasks to ExecutorService to return a List from a Room database. Other answers suggest using a Callable and a Future to return a value. Would appreciate your thoughts on that approach versus your easy and presumably efficient approach. – AJW Apr 13 '21 at 20:14