Как сказал Дейл, доступ к базе данных при блокировке пользовательского интерфейса в основном потоке является ошибкой.

- РЕДАКТИРОВАНИЕ 2 -

Поскольку многие люди могут столкнуться с этим ответом ... Лучший вариант в настоящее время, вообще говоря, - это Kotlin Coroutines. Room теперь поддерживает его напрямую (в настоящее время находится в стадии бета-тестирования). https://kotlinlang.org/docs/reference/coroutines-overview.html https://developer.android.com/jetpack/androidx/releases/room#2.1.0-beta01

- РЕДАКТИРОВАНИЕ 1 -

Для людей, интересующихся ... У вас есть другие варианты. Я рекомендую взглянуть на новые компоненты ViewModel и LiveData. LiveData отлично работает с Room. https://developer.android.com/topic/libraries/architecture/livedata.html

Другой вариант - это RxJava / RxAndroid. Более мощный, но более сложный, чем LiveData. https://github.com/ReactiveX/RxJava

--Оригинальный ответ -

Создайте статический вложенный класс (для предотвращения утечки памяти) в своей Activity, расширяющей AsyncTask.

private static class AgentAsyncTask extends AsyncTask<Void, Void, Integer> {

    //Prevent leak
    private WeakReference<Activity> weakActivity;
    private String email;
    private String phone;
    private String license;

    public AgentAsyncTask(Activity activity, String email, String phone, String license) {
        weakActivity = new WeakReference<>(activity);
        this.email = email;
        this.phone = phone;
        this.license = license;
    }

    @Override
    protected Integer doInBackground(Void... params) {
        AgentDao agentDao = MyApp.DatabaseSetup.getDatabase().agentDao();
        return agentDao.agentsCount(email, phone, license);
    }

    @Override
    protected void onPostExecute(Integer agentsCount) {
        Activity activity = weakActivity.get();
        if(activity == null) {
            return;
        }

        if (agentsCount > 0) {
            //2: If it already exists then prompt user
            Toast.makeText(activity, "Agent already exists!", Toast.LENGTH_LONG).show();
        } else {
            Toast.makeText(activity, "Agent does not exist! Hurray :)", Toast.LENGTH_LONG).show();
            activity.onBackPressed();
        }
    }
}

Или вы можете создать последний класс в отдельном файле.

Затем выполните его в методе signUpAction (View view):

new AgentAsyncTask(this, email, phone, license).execute();

В некоторых случаях вы также можете сохранить ссылку на AgentAsyncTask в своей деятельности, чтобы вы могли отменить ее, когда действие будет уничтожено. Но вам придется самому прерывать любые транзакции.

Кроме того, ваш вопрос о тестовом примере Google ... Они заявляют на этой веб-странице:

Рекомендуемый подход для тестирования реализации вашей базы данных - это написание теста JUnit, который запускается на устройстве Android. Поскольку эти тесты не требуют создания активности, они должны выполняться быстрее, чем тесты пользовательского интерфейса.

Нет активности, нет пользовательского интерфейса.

Это не рекомендуется, но вы можете получить доступ к базе данных в основном потоке с помощью allowMainThreadQueries()

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

Котлинские сопрограммы (ясные и лаконичные)

AsyncTask действительно неуклюжий. Сопрограммы - более чистая альтернатива (просто добавьте пару ключевых слов, и ваш код синхронизации станет асинхронным).

// Step 1: add `suspend` to your fun
suspend fun roomFun(...): Int
suspend fun notRoomFun(...) = withContext(Dispatchers.IO) { ... }

// Step 2: launch from coroutine scope
private fun myFun() {
    lifecycleScope.launch { // coroutine on Main
        val queryResult = roomFun(...) // coroutine on IO
        doStuff() // ...back on Main
    }
}

Зависимости (добавляет области сопрограмм для компонентов арки):

// lifecycleScope:
implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.2.0-alpha04'

// viewModelScope:
implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0-alpha04'

- Обновления:
8 мая 2019 г .: Room 2.1 теперь поддерживает suspend
13 сентября 2019 г .: Обновлено для использования Компоненты архитектуры объем

Для всех RxJava или RxAndroid или любители RxKotlin

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

Вы не можете запустить его в основном потоке, вместо этого используйте обработчики, асинхронные или рабочие потоки. Пример кода доступен здесь, а статью о библиотеке комнат можно прочитать здесь: Библиотека комнат Android

/**
 *  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();
    }
});

Если вы хотите запустить его в основном потоке, что не является предпочтительным способом.

Вы можете использовать этот метод для достижения в основном потоке Room.inMemoryDatabaseBuilder()

С lambda его легко запустить с помощью AsyncTask

 AsyncTask.execute(() -> //run your query here );

Просто выполняйте операции с базой данных в отдельном потоке. Вот так (Котлин):

Thread {
   //Do your database´s operations here
}.start()

С библиотекой Jetbrains Anko вы можете использовать метод doAsync {..} для автоматического выполнения вызовов базы данных. Это решает проблему многословия, которая у вас, казалось, была с ответом mcastro.

Пример использования:

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

Я часто использую это для вставок и обновлений, однако для избранных запросов я рекомендую использовать рабочий процесс RX.

Просто вы можете использовать этот код для его решения:

Executors.newSingleThreadExecutor().execute(new Runnable() {
                    @Override
                    public void run() {
                        appDb.daoAccess().someJobes();//replace with your code
                    }
                });

Или в лямбде вы можете использовать этот код:

Executors.newSingleThreadExecutor().execute(() -> appDb.daoAccess().someJobes());

Вы можете заменить appDb.daoAccess().someJobes() своим собственным кодом;

Вы должны выполнить запрос в фоновом режиме. Простым способом может быть использование Executors:

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

Поскольку asyncTask устарели, мы можем использовать службу исполнителя. ИЛИ вы также можете использовать ViewModel с LiveData как объяснил в других ответах.

Для использования службы исполнителя вы можете использовать что-то вроде ниже.

public class DbHelper {

    private final Executor executor = Executors.newSingleThreadExecutor();

    public void fetchData(DataFetchListener dataListener){
        executor.execute(() -> {
                Object object = retrieveAgent(agentId);
                new Handler(Looper.getMainLooper()).post(() -> {
                        dataListener.onFetchDataSuccess(object);
                });
        });
    }
}

Используется основной цикл, поэтому вы можете получить доступ к элементу пользовательского интерфейса из обратного вызова onFetchDataSuccess.

Для быстрых запросов вы можете оставить место для выполнения в потоке пользовательского интерфейса.

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

В моем случае мне пришлось выяснить, существует ли в базе данных выбранный пользователь в списке или нет. Если нет, то создайте пользователя и начните другое действие.

       @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);
        }
    }

Элегантное решение RxJava / Kotlin - использовать _ 1_, что даст вам Observable, который не возвращает значение, но может наблюдать и подписываться в другом потоке.

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)
}

Вы можете наблюдать и подписываться, как обычно:

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

Вы можете разрешить доступ к базе данных в основном потоке, но только для целей отладки, вы не должны этого делать в производственной среде.

Вот причина.

Примечание. Room не поддерживает доступ к базе данных в основном потоке, если вы не вызвали allowMainThreadQueries () в построителе, потому что это может заблокировать пользовательский интерфейс на длительный период времени. Асинхронные запросы - запросы, возвращающие экземпляры LiveData или Flowable - не подпадают под это правило, поскольку они асинхронно запускают запрос в фоновом потоке, когда это необходимо.

Если вам удобнее использовать Асинхронную задачу:

  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();

Обновление: я также получил это сообщение, когда пытался создать запрос с использованием @RawQuery и SupportSQLiteQuery внутри DAO.

@Transaction
public LiveData<List<MyEntity>> getList(MySettings mySettings) {
    //return getMyList(); -->this is ok

    return getMyList(new SimpleSQLiteQuery("select * from mytable")); --> this is an error

Решение: создайте запрос внутри ViewModel и передайте его в DAO.

public MyViewModel(Application application) {
...
        list = Transformations.switchMap(searchParams, params -> {

            StringBuilder sql;
            sql = new StringBuilder("select  ... ");

            return appDatabase.rawDao().getList(new SimpleSQLiteQuery(sql.toString()));

        });
    }

Or...

Вы не должны обращаться к базе данных непосредственно в основном потоке, например:

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

Вы должны использовать AsyncTask для операций обновления, добавления и удаления.

Пример:

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;
        }

    }
}

Если вы используете LiveData для выбранных операций, вам не понадобится AsyncTask.

Сообщение об ошибке,

Невозможно получить доступ к базе данных в основном потоке, так как он может заблокировать пользовательский интерфейс на длительные периоды времени.

Достаточно информативен и точен. Вопрос в том, как избежать доступа к базе данных в основном потоке. Это огромная тема, но для начала ознакомьтесь с AsyncTask (нажмите здесь)

-----РЕДАКТИРОВАТЬ----------

Я вижу, у вас проблемы при запуске модульного теста. У вас есть несколько способов исправить это:

1. Запустите тест непосредственно на машине разработки, а не на устройстве Android (или эмуляторе). Это работает для тестов, которые ориентированы на базу данных и не заботятся о том, выполняются ли они на устройстве.

2. Используйте аннотацию @RunWith(AndroidJUnit4.class) для запуска теста на устройстве Android, но не в действии с пользовательским интерфейсом. Более подробную информацию об этом можно найти в этом руководстве < / а>

Вы можете использовать Future и Callable. Таким образом, вам не нужно будет писать длинную асинхронную задачу и вы можете выполнять свои запросы без добавления allowMainThreadQueries ().

Мой запрос дао: -

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

Мой метод репозитория: -

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();
}

На мой взгляд, правильнее всего делегировать запрос потоку ввода-вывода с помощью RxJava.

У меня есть пример решения аналогичной проблемы, с которой я только что столкнулся.

((ProgressBar) view.findViewById(R.id.progressBar_home)).setVisibility(View.VISIBLE);//Always good to set some good feedback
        Completable.fromAction(() -> {
            //Creating view model requires DB access
            homeViewModel = new ViewModelProvider(this, factory).get(HomeViewModel.class);
        }).subscribeOn(Schedulers.io())//The DB access executes on a non-main-thread thread
        .observeOn(AndroidSchedulers.mainThread())//Upon completion of the DB-involved execution, the continuation runs on the main thread
        .subscribe(
                () ->
                {
                    mAdapter = new MyAdapter(homeViewModel.getExams());
                    recyclerView.setAdapter(mAdapter);
                    ((ProgressBar) view.findViewById(R.id.progressBar_home)).setVisibility(View.INVISIBLE);
                },
                error -> error.printStackTrace()
        );

И если мы хотим обобщить решение:

((ProgressBar) view.findViewById(R.id.progressBar_home)).setVisibility(View.VISIBLE);//Always good to set some good feedback
        Completable.fromAction(() -> {
            someTaskThatTakesTooMuchTime();
        }).subscribeOn(Schedulers.io())//The long task executes on a non-main-thread thread
        .observeOn(AndroidSchedulers.mainThread())//Upon completion of the DB-involved execution, the continuation runs on the main thread
        .subscribe(
                () ->
                {
                    taskIWantToDoOnTheMainThreadWhenTheLongTaskIsDone();
                },
                error -> error.printStackTrace()
        );