Nie jest to zalecane, ale możesz uzyskać dostęp do bazy danych w głównym wątku za pomocą allowMainThreadQueries()

MyApp.database =  Room.databaseBuilder(this, AppDatabase::class.java, "MyDatabase").allowMainThreadQueries().build()

Dla wszystkich RxJava lub RxAndroid lub rxkotlin

Observable.just(db)
          .subscribeOn(Schedulers.io())
          .subscribe { db -> // database operation }

Prosty kod wykorzystujący Koroutiny Kotlina

AsyncTask jest naprawdę niezgrabny. Kotlin coroutines jest czystszą alternatywą (zasadniczo tylko twój synchroniczny kod z kilkoma dodatkowymi słowami kluczowymi).

gradle.właściwości:

# Coroutines opt-in
kotlin.coroutines=enable

UI thread (non-blocking):

private fun myFun() {
    launch(UI) {
        val query = async(CommonPool) { // Async stuff
            MyApp.DatabaseSetup.database.agentDao().agentsCount(email, phone, license)
        }

        val agentsCount = query.await()
        // do UI stuff
    }
}

Słowo kluczowe suspend zapewnia, że metody asynchroniczne są wywoływane tylko z bloków asynchronicznych, jednak (jak zauważył @ Robin )nie pasuje to do pokoju z adnotacją metody.

// Wrap API to use suspend (probably not worth it)
public suspend fun agentsCount(...): Int = agentsCountPrivate(...)

@Query("SELECT ...")
protected abstract fun agentsCountPrivate(...): Int

Nie można go uruchomić w głównym wątku zamiast tego użyć programów obsługi, asynchronicznych lub roboczych wątków . Przykładowy kod jest dostępny tutaj i przeczytaj artykuł o room library tutaj: Android ' s Room Library

/**
 *  Insert and get data using Database Async way
 */
AsyncTask.execute(new Runnable() {
    @Override
    public void run() {
        // Insert Data
        AppDatabase.getInstance(context).userDao().insert(new User(1,"James","Mathew"));

        // Get Data
        AppDatabase.getInstance(context).userDao().getAllUsers();
    }
});

Jeśli chcesz uruchomić go na głównym wątku, który nie jest preferowany sposób .

Możesz użyć tej metody, aby osiągnąć na głównym wątku Room.inMemoryDatabaseBuilder()

Z biblioteką Jetbrains Anko możesz użyć doasync{..} metoda automatycznego wykonywania wywołań bazy danych. To rozwiązuje problem gadatliwości, który wydaje ci się mieć z odpowiedzią mcastro.

Przykładowe użycie:

    doAsync { 
        Application.database.myDAO().insertUser(user) 
    }

Używam tego często do wstawiania i aktualizacji, jednak dla zapytań select polecam korzystanie z obiegu pracy RX.

Eleganckim rozwiązaniem RxJava / Kotlin jest użycie Completable.fromCallable, co da Ci obserwowalny, który nie zwraca wartości, ale może być obserwowany i subskrybowany w innym wątku.

public Completable insert(Event event) {
    return Completable.fromCallable(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            return database.eventDao().insert(event)
        }
    }
}

fun insert(event: Event) : Completable = Completable.fromCallable {
    database.eventDao().insert(event)
}

Możesz obserwować i subskrybować, jak zwykle:

dataManager.insert(event)
    .subscribeOn(scheduler)
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(...)

Musisz wykonać żądanie w tle. Prostym sposobem może być użycie Executors :

Executors.newSingleThreadExecutor().execute { 
   yourDb.yourDao.yourRequest() //Replace this by your request
}

Komunikat o błędzie,

Nie można uzyskać dostępu do bazy danych w głównym wątku, ponieważ może potencjalnie zablokować interfejs użytkownika na długi czas.

Jest dość opisowy i dokładny. Pytanie brzmi, jak uniknąć dostępu do bazy danych w głównym wątku. To ogromny temat, ale aby zacząć, przeczytaj o AsyncTask (kliknij tutaj)

-----edytuj----------

1. Uruchom test bezpośrednio na maszynie deweloperskiej, a nie na urządzeniu z Androidem (lub emulatorze). Działa to w przypadku testów, które są skoncentrowane na bazie danych i tak naprawdę nie dbają o to, czy są uruchomione na urządzeniu.

2. Użyj adnotacji @RunWith(AndroidJUnit4.class) aby uruchomić test na urządzeniu z Androidem, ale nie w aktywności z interfejsem użytkownika. Więcej szczegółów na ten temat można znaleźć w tym samouczku

Jeśli wolisz asynchroniczne Zadanie :

  new AsyncTask<Void, Void, Integer>() {
                @Override
                protected Integer doInBackground(Void... voids) {
                    return Room.databaseBuilder(getApplicationContext(),
                            AppDatabase.class, DATABASE_NAME)
                            .fallbackToDestructiveMigration()
                            .build()
                            .getRecordingDAO()
                            .getAll()
                            .size();
                }

                @Override
                protected void onPostExecute(Integer integer) {
                    super.onPostExecute(integer);
                    Toast.makeText(HomeActivity.this, "Found " + integer, Toast.LENGTH_LONG).show();
                }
            }.execute();

Dla szybkich zapytań możesz zezwolić pokojowi na wykonanie go w wątku UI.

AppDatabase db = Room.databaseBuilder(context.getApplicationContext(),
        AppDatabase.class, DATABASE_NAME).allowMainThreadQueries().build();

W moim przypadku musiałem dowiedzieć się, że kliknięty użytkownik na liście istnieje w bazie danych lub nie. Jeśli nie, Utwórz użytkownika i rozpocznij inną aktywność

       @Override
        public void onClick(View view) {



            int position = getAdapterPosition();

            User user = new User();
            String name = getName(position);
            user.setName(name);

            AppDatabase appDatabase = DatabaseCreator.getInstance(mContext).getDatabase();
            UserDao userDao = appDatabase.getUserDao();
            ArrayList<User> users = new ArrayList<User>();
            users.add(user);
            List<Long> ids = userDao.insertAll(users);

            Long id = ids.get(0);
            if(id == -1)
            {
                user = userDao.getUser(name);
                user.setId(user.getId());
            }
            else
            {
                user.setId(id);
            }

            Intent intent = new Intent(mContext, ChatActivity.class);
            intent.putExtra(ChatActivity.EXTRAS_USER, Parcels.wrap(user));
            mContext.startActivity(intent);
        }
    }

Możesz zezwolić na dostęp do bazy danych w głównym wątku, ale tylko w celu debugowania, nie powinieneś tego robić podczas produkcji.

Oto powód.

Uwaga: pokój nie obsługuje dostępu do bazy danych w głównym wątku, chyba że wywołałeś allowmainthreadqueries () w konstruktorze, ponieważ może to zablokować interfejs użytkownika na długi okres czasu. Asynchronous queries-zapytania zwracające instancje LiveData lub Flowable - są zwolnione z tej reguły, ponieważ asynchronicznie uruchamiają zapytanie w razie potrzeby na wątku tła.

Nie możesz uzyskać dostępu do bazy danych bezpośrednio w głównym wątku, na przykład:

 public void add(MyEntity item) {
     appDatabase.myDao().add(item); 
 }

Musisz rozszerzyć AsyncTask dla aktualizacji, dodawania i usuwania w ViewModel.

Przykład:

public class MyViewModel extends AndroidViewModel {

    private LiveData<List<MyEntity>> list;

    private AppDatabase appDatabase;

    public MyViewModel(Application application) {
        super(application);

        appDatabase = AppDatabase.getDatabase(this.getApplication());
        list = appDatabase.myDao().getItems();
    }

    public LiveData<List<MyEntity>> getItems() {
        return list;
    }

    public void delete(Obj item) {
        new deleteAsyncTask(appDatabase).execute(item);
    }

    private static class deleteAsyncTask extends AsyncTask<MyEntity, Void, Void> {

        private AppDatabase db;

        deleteAsyncTask(AppDatabase appDatabase) {
            db = appDatabase;
        }

        @Override
        protected Void doInBackground(final MyEntity... params) {
            db.myDao().delete((params[0]));
            return null;
        }
    }

    public void add(final MyEntity item) {
        new addAsyncTask(appDatabase).execute(item);
    }

    private static class addAsyncTask extends AsyncTask<MyEntity, Void, Void> {

        private AppDatabase db;

        addAsyncTask(AppDatabase appDatabase) {
            db = appDatabase;
        }

        @Override
        protected Void doInBackground(final MyEntity... params) {
            db.myDao().add((params[0]));
            return null;
        }

    }
}

Możesz użyć Future I Callable. Tak więc nie będziesz musiał pisać długich asynctask i możesz wykonywać swoje zapytania bez dodawania allowMainThreadQueries ().

Moje zapytanie dao: -

@Query("SELECT * from user_data_table where SNO = 1")
UserData getDefaultData();

Moja metoda repozytorium:-

public UserData getDefaultData() throws ExecutionException, InterruptedException {

    Callable<UserData> callable = new Callable<UserData>() {
        @Override
        public UserData call() throws Exception {
            return userDao.getDefaultData();
        }
    };

    Future<UserData> future = Executors.newSingleThreadExecutor().submit(callable);

    return future.get();
}