J'essaye un échantillon avec la bibliothèque de persistance de pièce . J'ai créé une entité:

@Entity
public class Agent {
    @PrimaryKey
    public String guid;
    public String name;
    public String email;
    public String password;
    public String phone;
    public String licence;
}

Création d'une classe DAO:

@Dao
public interface AgentDao {
    @Query("SELECT COUNT(*) FROM Agent where email = :email OR phone = :phone OR licence = :licence")
    int agentsCount(String email, String phone, String licence);

    @Insert
    void insertAgent(Agent agent);
}

Création de la classe Database:

@Database(entities = {Agent.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
    public abstract AgentDao agentDao();
}

Base de données exposée en utilisant la sous-classe ci-dessous dans Kotlin:

class MyApp : Application() {

    companion object DatabaseSetup {
        var database: AppDatabase? = null
    }

    override fun onCreate() {
        super.onCreate()
        MyApp.database =  Room.databaseBuilder(this, AppDatabase::class.java, "MyDatabase").build()
    }
}

Fonction implémentée ci-dessous dans mon activité:

void signUpAction(View view) {
        String email = editTextEmail.getText().toString();
        String phone = editTextPhone.getText().toString();
        String license = editTextLicence.getText().toString();

        AgentDao agentDao = MyApp.DatabaseSetup.getDatabase().agentDao();
        //1: Check if agent already exists
        int agentsCount = agentDao.agentsCount(email, phone, license);
        if (agentsCount > 0) {
            //2: If it already exists then prompt user
            Toast.makeText(this, "Agent already exists!", Toast.LENGTH_LONG).show();
        }
        else {
            Toast.makeText(this, "Agent does not exist! Hurray :)", Toast.LENGTH_LONG).show();
            onBackPressed();
        }
    }

Malheureusement, lors de l'exécution de la méthode ci-dessus, il se bloque avec la trace de pile ci-dessous:

    FATAL EXCEPTION: main
 Process: com.example.me.MyApp, PID: 31592
java.lang.IllegalStateException: Could not execute method for android:onClick
    at android.support.v7.app.AppCompatViewInflater$DeclaredOnClickListener.onClick(AppCompatViewInflater.java:293)
    at android.view.View.performClick(View.java:5612)
    at android.view.View$PerformClick.run(View.java:22288)
    at android.os.Handler.handleCallback(Handler.java:751)
    at android.os.Handler.dispatchMessage(Handler.java:95)
    at android.os.Looper.loop(Looper.java:154)
    at android.app.ActivityThread.main(ActivityThread.java:6123)
    at java.lang.reflect.Method.invoke(Native Method)
    at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:867)
    at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:757)
 Caused by: java.lang.reflect.InvocationTargetException
    at java.lang.reflect.Method.invoke(Native Method)
    at android.support.v7.app.AppCompatViewInflater$DeclaredOnClickListener.onClick(AppCompatViewInflater.java:288)
    at android.view.View.performClick(View.java:5612) 
    at android.view.View$PerformClick.run(View.java:22288) 
    at android.os.Handler.handleCallback(Handler.java:751) 
    at android.os.Handler.dispatchMessage(Handler.java:95) 
    at android.os.Looper.loop(Looper.java:154) 
    at android.app.ActivityThread.main(ActivityThread.java:6123) 
    at java.lang.reflect.Method.invoke(Native Method) 
    at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:867) 
    at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:757) 
 Caused by: java.lang.IllegalStateException: Cannot access database on the main thread since it may potentially lock the UI for a long periods of time.
    at android.arch.persistence.room.RoomDatabase.assertNotMainThread(RoomDatabase.java:137)
    at android.arch.persistence.room.RoomDatabase.query(RoomDatabase.java:165)
    at com.example.me.MyApp.RoomDb.Dao.AgentDao_Impl.agentsCount(AgentDao_Impl.java:94)
    at com.example.me.MyApp.View.SignUpActivity.signUpAction(SignUpActivity.java:58)
    at java.lang.reflect.Method.invoke(Native Method) 
    at android.support.v7.app.AppCompatViewInflater$DeclaredOnClickListener.onClick(AppCompatViewInflater.java:288) 
    at android.view.View.performClick(View.java:5612) 
    at android.view.View$PerformClick.run(View.java:22288) 
    at android.os.Handler.handleCallback(Handler.java:751) 
    at android.os.Handler.dispatchMessage(Handler.java:95) 
    at android.os.Looper.loop(Looper.java:154) 
    at android.app.ActivityThread.main(ActivityThread.java:6123) 
    at java.lang.reflect.Method.invoke(Native Method) 
    at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:867) 
    at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:757) 

Il semble que ce problème soit lié à l'exécution de l'opération db sur le thread principal. Cependant, l'exemple de code de test fourni dans le lien ci-dessus ne s'exécute pas sur un thread distinct:

@Test
    public void writeUserAndReadInList() throws Exception {
        User user = TestUtil.createUser(3);
        user.setName("george");
        mUserDao.insert(user);
        List<User> byName = mUserDao.findUsersByName("george");
        assertThat(byName.get(0), equalTo(user));
    }

Est-ce que je manque quelque chose ici? Comment puis-je l'exécuter sans planter? Veuillez suggérer.

L'accès à la base de données sur le thread principal verrouillant l'interface utilisateur est l'erreur, comme l'a dit Dale.

Créez une classe imbriquée statique (pour éviter les fuites de mémoire) dans votre activité en étendant 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();
        }
    }
}

Ou vous pouvez créer une classe finale sur son propre fichier.

Puis exécutez-le dans la méthode signUpAction (View view):

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

Dans certains cas, vous souhaiterez peut-être également conserver une référence à AgentAsyncTask dans votre activité afin de pouvoir l'annuler lorsque l'activité est détruite. Mais vous devrez interrompre vous-même toutes les transactions.

Aussi, votre question sur l'exemple de test de Google ... Ils indiquent dans cette page Web:

L'approche recommandée pour tester l'implémentation de votre base de données consiste à écrire un test JUnit qui s'exécute sur un appareil Android. Étant donné que ces tests ne nécessitent pas la création d'une activité, ils devraient être plus rapides à exécuter que vos tests d'interface utilisateur.

Aucune activité, aucune interface utilisateur.

--ÉDITER--

Pour les gens qui se demandent ... Vous avez d'autres options. Je recommande de jeter un œil aux nouveaux composants ViewModel et LiveData. LiveData fonctionne parfaitement avec Room. https://developer.android.com/topic/libraries/architecture/livedata.html

Une autre option est le RxJava / RxAndroid. Plus puissant mais plus complexe que LiveData. https://github.com/ReactiveX/RxJava

--EDIT 2--

Puisque beaucoup de gens peuvent trouver cette réponse ... La meilleure option de nos jours, en général, est Kotlin Coroutines. Room le prend désormais en charge directement (actuellement en version bêta). https://kotlinlang.org/docs/reference/coroutines-overview.html https://developer.android.com/jetpack/androidx/releases/room#2.1.0-beta01

Ce n'est pas recommandé mais vous pouvez accéder à la base de données sur le thread principal avec allowMainThreadQueries()

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

Kotlin Coroutines (clair et concis)

AsyncTask est vraiment maladroit. Les coroutines sont une alternative plus propre (il suffit de saupoudrer quelques mots-clés et votre code de synchronisation devient asynchrone).

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

Dépendances (ajoute des portées coroutines pour les composants de l'arche):

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

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

- Mises à jour:
8 mai 2019: la salle 2.1 prend désormais en charge suspend
13 septembre 2019: mise à jour pour utiliser la portée des composants d'architecture

Pour tous les RxJava ou RxAndroid ou RxKotlin amateurs là - bas

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

Vous ne pouvez pas l'exécuter sur le thread principal à la place, utilisez des gestionnaires, des threads asynchrones ou de travail. Un exemple de code est disponible ici et lisez l'article sur la bibliothèque de la salle ici: Bibliothèque de la salle d'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();
    }
});

Si vous souhaitez l'exécuter sur le thread principal, ce n'est pas la manière préférée.

Vous pouvez utiliser cette méthode pour réaliser sur le fil principal Room.inMemoryDatabaseBuilder()

Avec lambda, il est facile à exécuter avec AsyncTask

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

Avec la bibliothèque Jetbrains Anko, vous pouvez utiliser la méthode doAsync {..} pour exécuter automatiquement des appels de base de données. Cela résout le problème de verbosité que vous sembliez avoir avec la réponse de mcastro.

Exemple d'utilisation:

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

Je l'utilise fréquemment pour les insertions et les mises à jour, mais pour certaines requêtes, je recommande d'utiliser le flux de travail RX.

Effectuez simplement les opérations de base de données dans un thread séparé. Comme ça (Kotlin):

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

Vous devez exécuter la demande en arrière-plan. Un moyen simple pourrait être d'utiliser un exécuteur :

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

Une solution RxJava / Kotlin élégante est à utiliser Completable.fromCallable, qui vous donnera un Observable qui ne retourne pas de valeur, mais peut être observé et abonné sur un thread différent.

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

Ou à Kotlin:

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

Vous pouvez l'observer et vous abonner comme vous le feriez habituellement:

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

Vous pouvez autoriser l'accès à la base de données sur le thread principal, mais uniquement à des fins de débogage, vous ne devriez pas le faire en production.

Voici la raison.

Remarque: Room ne prend pas en charge l'accès à la base de données sur le thread principal, sauf si vous avez appelé allowMainThreadQueries () sur le générateur, car il peut verrouiller l'interface utilisateur pendant une longue période. Les requêtes asynchrones (requêtes qui renvoient des instances de LiveData ou Flowable) sont exemptées de cette règle car elles exécutent la requête de manière asynchrone sur un thread d'arrière-plan lorsque cela est nécessaire.

Vous pouvez simplement utiliser ce code pour le résoudre:

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

Ou en lambda, vous pouvez utiliser ce code:

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

Vous pouvez remplacer appDb.daoAccess().someJobes()par votre propre code;

Comme asyncTask est obsolète, nous pouvons utiliser le service exécuteur. OU vous pouvez également utiliser ViewModel avec LiveData comme expliqué dans d'autres réponses.

Pour utiliser le service exécuteur, vous pouvez utiliser quelque chose comme ci-dessous.

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

Main Looper est utilisé, de sorte que vous pouvez accéder à l'élément d'interface utilisateur à partir du onFetchDataSuccessrappel.

Le message d'erreur,

Impossible d'accéder à la base de données sur le thread principal car il peut potentiellement verrouiller l'interface utilisateur pendant de longues périodes.

Est assez descriptif et précis. La question est de savoir comment éviter d'accéder à la base de données sur le thread principal. C'est un sujet énorme, mais pour commencer, lisez AsyncTask (cliquez ici)

-----ÉDITER----------

Je vois que vous rencontrez des problèmes lorsque vous exécutez un test unitaire. Vous avez plusieurs choix pour résoudre ce problème:

1. Exécutez le test directement sur la machine de développement plutôt que sur un appareil Android (ou un émulateur). Cela fonctionne pour les tests centrés sur la base de données et ne se soucient pas vraiment de savoir s'ils s'exécutent sur un appareil.

2. Utilisez l'annotation @RunWith(AndroidJUnit4.class) pour exécuter le test sur l'appareil Android, mais pas dans une activité avec une interface utilisateur. Plus de détails à ce sujet peuvent être trouvés dans ce tutoriel

Si vous êtes plus à l'aise avec la tâche Async :

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

Mise à jour: J'ai également reçu ce message lorsque j'essayais de créer une requête en utilisant @RawQuery et SupportSQLiteQuery dans le 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

Solution: créez la requête à l'intérieur du ViewModel et transmettez-la au DAO.

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

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

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

        });
    }

Ou...

Vous ne devez pas accéder à la base de données directement sur le thread principal, par exemple:

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

Vous devez utiliser AsyncTask pour les opérations de mise à jour, d'ajout et de suppression.

Exemple:

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

    }
}

Si vous utilisez LiveData pour sélectionner des opérations, vous n'avez pas besoin d'AsyncTask.

Pour les requêtes rapides, vous pouvez autoriser la salle à l'exécuter sur le fil de l'interface utilisateur.

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

Dans mon cas, j'ai dû comprendre que l'utilisateur cliqué dans la liste existe ou non dans la base de données. Sinon, créez l'utilisateur et démarrez une autre activité

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

Vous pouvez utiliser Future et Callable. Ainsi, vous ne seriez pas obligé d'écrire une longue asynctask et pouvez effectuer vos requêtes sans ajouter allowMainThreadQueries ().

Ma requête dao: -

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

Ma méthode de dépôt: -

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

À mon avis, la bonne chose à faire est de déléguer la requête à un thread IO en utilisant RxJava.

J'ai un exemple de solution à un problème équivalent que je viens de rencontrer.

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

Et si nous voulons généraliser la solution:

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