Android Chambre simple requête select - Ne peut pas accéder à la base de données sur le thread principal

Base de données d'accès sur le thread principal de verrouillage de l'INTERFACE utilisateur est l'erreur, comme Dale a dit.

Créer une statique de la classe imbriquée (pour empêcher la fuite de mémoire) dans votre Activité s'é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 l'exécuter dans le signUpAction(View vue) méthode:

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

Dans certains cas, vous pouvez également maintenir une référence à l'AgentAsyncTask dans votre activité, de sorte que vous pouvez l'annuler lorsque l'Activité est détruite. Mais vous devez interrompre les opérations vous-même.

Aussi, à votre question sur le Google test exemple...
Dans cette page web:

L'approche recommandée pour le test de votre base de données est mise en œuvre
écrire un test Unitaire qui s'exécute sur un périphérique Android. Parce que ces
les tests ne nécessitent pas la création d'une activité, ils devraient être plus rapide à
exécution de vos tests de l'INTERFACE utilisateur.

Aucune Activité, aucune INTERFACE utilisateur.

--EDIT--

Pour des gens qui se demandent... Vous avez d'autres options.
Je vous recommande de prendre un coup d'oeil dans la nouvelle ViewModel et LiveData composants. LiveData fonctionne très bien avec de la place.
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--

Depuis de nombreuses personnes peuvent trouver cette réponse...
La meilleure option aujourd'hui, d'une manière générale, est Kotlin Coroutines. La chambre prend désormais en charge directement (actuellement en bêta).
https://kotlinlang.org/docs/reference/coroutines-overview.html
https://developer.android.com/jetpack/androidx/releases/room#2.1.0-beta01

Pour tous les RxJava ou RxAndroid ou RxKotlin amateurs de il

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

Vous ne pouvez pas l'exécuter sur le thread principal, au lieu d'utiliser des gestionnaires, asynchrone ou de travail threads . Un exemple de code est disponible ici et de lire l'article sur la salle de la bibliothèque ici : Android la Salle de la Bibliothèque

/**
*  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 voulez l'exécuter sur le thread principal qui n'est pas la méthode préférée .

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

Un élégant RxJava/Kotlin solution est d'utiliser Complétées.fromCallable, ce qui vous donnera une Observable qui ne retourne pas de valeur, mais peut observés et souscrit 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 dans Kotlin:

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

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

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

Le message d'erreur,

Ne peut pas accéder à la base de données sur le thread principal, car il peut potentiellement bloquer l'INTERFACE utilisateur pour une longue période de temps.

Est assez précis et descriptif. La question est de savoir comment devez-vous éviter de consulter la base de données sur le thread principal. C'est un vaste sujet, mais pour commencer, lisez à propos de AsyncTask (cliquez ici)

-----EDIT----------

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

1. Exécuter le test directement sur la machine de développement plutôt que sur un appareil Android (ou émulateur). Cela fonctionne pour les tests qui sont à la base de données centrée sur et ne me soucie pas vraiment de savoir s'ils sont en cours d'exécution sur un appareil.

2. Utiliser 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ées dans ce tutoriel

Vous avez à l'exécution de la demande au fond.
Un moyen simple pourrait être l'aide d'un Les exécuteurs :

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

Rapide de requêtes vous pouvez vous permettre de l'exécuter sur le thread de l'INTERFACE utilisateur.

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

Dans mon cas, j'ai eu de la figure de l'utilisateur a cliqué dans la liste existe dans la base de données ou non. Si non, alors de créer l'utilisateur et démarrer 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);
}
}

Simplement, vous pouvez utiliser ce code pour le résoudre:

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

Ou lambda, vous pouvez utiliser ce code:

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

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

Vous pouvez utiliser Avenir et Exigible. Si vous n'avez pas à écrire une longue asynctask et d'effectuer vos requêtes sans ajouter allowMainThreadQueries().

Ma requête dao:-

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

Mon référentiel méthode:-

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