Room Persistence Library ile bir örnek deniyorum . Bir Varlık oluşturdum:

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

DAO sınıfı oluşturuldu:

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

Veritabanı sınıfı oluşturuldu:

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

Kotlin'de aşağıdaki alt sınıf kullanılarak açığa çıkarılan veritabanı:

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

Faaliyetimde aşağıdaki işlevi uyguladı:

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

Maalesef yukarıdaki yöntemin yürütülmesi sırasında aşağıdaki yığın izleme ile çöküyor:

    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) 

Görünüşe göre bu sorun ana iş parçacığı üzerinde db işleminin yürütülmesi ile ilgili. Ancak yukarıdaki bağlantıda verilen örnek test kodu ayrı bir iş parçacığında çalışmaz:

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

Burada bir şey eksik mi? Kilitlenme olmadan nasıl çalıştırabilirim? Lütfen önerin.

Dale'in dediği gibi, UI'yi kilitleyen ana iş parçacığındaki veritabanı erişimi hatadır.

AsyncTask genişletme faaliyetinizde statik iç içe geçmiş bir sınıf oluşturun (bellek sızıntısını önlemek için).

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

Veya kendi dosyasında son bir sınıf oluşturabilirsiniz.

Ardından bunu signUpAction (Görünüm görünümü) yönteminde yürütün:

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

Bazı durumlarda, aktivitenizde AgentAsyncTask'e bir referans tutmak isteyebilirsiniz, böylece Aktivite yok edildiğinde onu iptal edebilirsiniz. Ancak herhangi bir işlemi kendiniz kesmeniz gerekir.

Ayrıca, Google'ın test örneğiyle ilgili sorunuz ... Bu web sayfasında şöyle yazıyorlar:

Veritabanı uygulamanızı test etmek için önerilen yaklaşım, bir Android cihazda çalışan bir JUnit testi yazmaktır. Bu testler bir aktivite oluşturmayı gerektirmediğinden, bunların yürütülmesi UI testlerinizden daha hızlı olmalıdır.

Etkinlik Yok, Kullanıcı Arayüzü Yok.

--DÜZENLE--

Merak edenler için ... Başka seçenekleriniz var. Yeni ViewModel ve LiveData bileşenlerine bir göz atmanızı tavsiye ederim. LiveData, Room ile harika çalışıyor. https://developer.android.com/topic/libraries/architecture/livedata.html

Diğer bir seçenek de RxJava / RxAndroid. LiveData'dan daha güçlü ancak daha karmaşık. https://github.com/ReactiveX/RxJava

- DÜZENLEME 2--

Pek çok kişi bu cevaba rastlayabileceği için ... Günümüzde genel anlamda en iyi seçenek Kotlin Coroutines. Oda artık bunu doğrudan destekliyor (şu anda beta sürümünde). https://kotlinlang.org/docs/reference/coroutines-overview.html https://developer.android.com/jetpack/androidx/releases/room#2.1.0-beta01

Önerilmez, ancak ana iş parçacığı üzerindeki veritabanına erişebilirsiniz. allowMainThreadQueries()

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

Kotlin Coroutines (Açık ve Kısa)

AsyncTask gerçekten hantal. Coroutinler daha temiz bir alternatiftir (sadece birkaç anahtar kelime serpiştirin ve senkronizasyon kodunuz eşzamansız hale gelir).

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

Bağımlılıklar (ark bileşenleri için eşgüdüm kapsamları ekler):

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

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

- Güncellemeler:
08 Mayıs 2019: Oda 2.1 artık suspend
13 Eylül 2019'u destekliyor : Mimari bileşenleri kapsamını kullanmak için güncellendi

Dışarıdaki tüm RxJava veya RxAndroid veya RxKotlin sevenler için

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

İşleyicileri, zaman uyumsuz veya çalışan evreleri kullanmak yerine ana iş parçacığı üzerinde çalıştıramazsınız. Örnek bir koda buradan ulaşabilirsiniz ve burada oda kitaplığı ile ilgili makaleyi okuyun: Android'in Oda Kitaplığı

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

Tercih edilmeyen bir şekilde ana iş parçacığı üzerinde çalıştırmak istiyorsanız.

Ana iş parçacığına ulaşmak için bu yöntemi kullanabilirsiniz. Room.inMemoryDatabaseBuilder()

Lambda ile AsyncTask ile çalıştırılması kolaydır

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

Jetbrains Anko kitaplığıyla, veritabanı çağrılarını otomatik olarak yürütmek için doAsync {..} yöntemini kullanabilirsiniz. Bu, mcastro'nun cevabıyla yaşadığınız ayrıntı problemini halleder.

Örnek kullanım:

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

Bunu sık sık eklemeler ve güncellemeler için kullanıyorum, ancak belirli sorgular için RX iş akışını kullanmayı öneriyorum.

Veritabanı işlemlerini ayrı bir Thread içerisinde yapmanız yeterlidir. Bunun gibi (Kotlin):

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

İsteği arka planda yürütmelisiniz. Bir Executors kullanmak basit bir yol olabilir :

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

Completable.fromCallableSize bir değer döndürmeyen, ancak farklı bir iş parçacığında gözlemlenebilen ve abone olabilen bir Observable verecek olan zarif bir RxJava / Kotlin çözümü kullanmaktır .

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

Veya Kotlin'de:

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

Genelde yaptığınız gibi gözlemleyebilir ve abone olabilirsiniz:

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

Ana iş parçacığı üzerinde veritabanı erişimine izin verebilirsiniz, ancak yalnızca hata ayıklama amacıyla bunu üretimde yapmamalısınız.

Nedeni burada.

Not: Kullanıcı arabirimini uzun bir süre kilitleyebileceğinden, oluşturucuda allowMainThreadQueries () öğesini çağırmadığınız sürece, oda ana iş parçacığındaki veritabanı erişimini desteklemez. Eşzamansız sorgular (LiveData veya Flowable örneklerini döndüren sorgular), gerektiğinde sorguyu arka planda eşzamansız olarak çalıştırdıkları için bu kuraldan muaftır.

Basitçe çözmek için bu kodu kullanabilirsiniz:

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

Veya lambda'da bu kodu kullanabilirsiniz:

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

appDb.daoAccess().someJobes()Kendi kodunuzla değiştirebilirsiniz ;

AsyncTask kullanımdan kaldırıldığından, yürütme hizmetini kullanabiliriz. VEYA ViewModel'i LiveData ile de kullanabilirsiniz diğer yanıtlarda açıklandığı gibi .

Yürütme hizmetini kullanmak için aşağıdaki gibi bir şey kullanabilirsiniz.

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

Geri aramadan UI öğesine erişebilmeniz için Ana Looper kullanılır onFetchDataSuccess.

Hata mesajı,

Kullanıcı arabirimini uzun süre kilitleyebileceği için ana iş parçacığındaki veritabanına erişilemiyor.

Oldukça açıklayıcı ve doğru. Soru, ana iş parçacığındaki veritabanına erişimden nasıl kaçınmanız gerektiğidir. Bu çok büyük bir konu, ancak başlamak için AsyncTask hakkında okuyun (buraya tıklayın)

-----DÜZENLE----------

Bir birim testi çalıştırdığınızda sorun yaşadığınızı görüyorum. Bunu düzeltmek için birkaç seçeneğiniz var:

1. Testi bir Android cihaz (veya emülatör) yerine doğrudan geliştirme makinesinde çalıştırın. Bu, veritabanı merkezli ve bir cihazda çalışıp çalışmadıklarıyla ilgilenmeyen testler için işe yarar.

2. @RunWith(AndroidJUnit4.class) Testi android cihazda çalıştırmak için notu kullanın , ancak kullanıcı arayüzlü bir aktivitede değil. Bununla ilgili daha fazla ayrıntı bu eğiticide bulunabilir .

Zaman uyumsuz görevde daha rahatsanız :

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

Güncelleme: DAO içinde @RawQuery ve SupportSQLiteQuery kullanarak bir sorgu oluşturmaya çalışırken de bu mesajı aldım.

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

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

Çözüm: Sorguyu ViewModel içinde oluşturun ve DAO'ya iletin.

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

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

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

        });
    }

Veya...

Veritabanına doğrudan ana iş parçacığından erişmemelisiniz, örneğin:

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

Güncelleme, ekleme ve silme işlemleri için AsyncTask kullanmalısınız.

Misal:

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

    }
}

Seçili işlemler için LiveData kullanıyorsanız, AsyncTask'a ihtiyacınız yoktur.

Hızlı sorgular için, odanın UI iş parçacığında yürütmesine izin verebilirsiniz.

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

Benim durumumda, listede tıklanan kullanıcının veritabanında olup olmadığını anlamak zorunda kaldım. Değilse, kullanıcıyı oluşturun ve başka bir etkinlik başlatın

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

Future ve Callable'ı kullanabilirsiniz. Böylece uzun bir eşzamansız görev yazmanız gerekmez ve allowMainThreadQueries () eklemeden sorgularınızı gerçekleştirebilirsiniz.

Dao sorgum: -

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

Depo yöntemim: -

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

Bence yapılacak doğru şey, sorguyu RxJava kullanarak bir IO iş parçacığına delege etmektir.

Az önce karşılaştığım eşdeğer bir soruna bir çözüm örneğim var.

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

Çözümü genellemek istiyorsak:

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