Room Database RxJava Background Thread

beastlyCoder :

I am trying to use my RoomDatabase on the background thread, using RxJava.

My DAO class:

import android.arch.persistence.room.Dao;
import android.arch.persistence.room.Insert;
import java.util.List;

@Dao
public interface MeasurementDAO
{
    @Insert
    public void insertMeasurements(Measurements m);
}

My Entity class (getter and setter methods left out for brevity):

import android.arch.persistence.room.Entity;
import android.arch.persistence.room.PrimaryKey;
import android.support.annotation.NonNull;

@Entity
public class Measurements
{
    @NonNull
    @PrimaryKey
    public String mId;
    public String finalResultIn;
    public String finalResultFt;


    public String lengthFt;
    public String widthFt;
    public String heightFt;

    public String lengthIn;
    public String widthIn;
    public String heightIn;

    public Measurements(String finalResultFt, String finalResultIn, String lengthFt, String widthFt, String heightFt,
                        String lengthIn, String widthIn, String heightIn)
    {
        this.finalResultFt = finalResultFt;
        this.finalResultIn = finalResultIn;

        this.lengthFt = lengthFt;
        this.widthFt = widthFt;
        this.heightFt = heightFt;

        this.lengthIn = lengthIn;
        this.widthIn = widthIn;
        this.heightIn = heightIn;
    }
    }

Finally, here is my MeasurementDatabase class:

@Database(entities = {Measurements.class}, version = 1)
public abstract class MeasurementDatabase extends RoomDatabase
{
    private static final String DB_NAME = "measurement_db";
    private static MeasurementDatabase instance;

    public static synchronized  MeasurementDatabase getInstance(Context context)
    {
        if(instance == null)
        {
            instance = Room.databaseBuilder(context.getApplicationContext(), MeasurementDatabase.class,
                    DB_NAME)
                    .fallbackToDestructiveMigration()
                    .build();
        }
        return instance;
    }

    public abstract MeasurementDAO measurementDAO();
}

In my fragment, I'm trying to insert on the background thread once a menu item is clicked:

final MeasurementDatabase appDb =

MeasurementDatabase.getInstance(getActivity());


                //fill the values with the appropriate;
                final Measurements m = new Measurements(
                        cubicInches.getText().toString(),
                        cubicFeet.getText().toString(),
                        len_ft.getText().toString(),
                        width_ft.getText().toString(),
                        height_ft.getText().toString(),
                        len_in.getText().toString(),
                        width_in.getText().toString(),
                        height_in.getText().toString());

                Observable.just(appDb)
                        .subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread())
                        .subscribe(new Observer<MeasurementDatabase>(){

                            @Override
                            public void onSubscribe(Disposable d) {
                                appDb.measurementDAO().insertMeasurements(m);

                            }

                            @Override
                            public void onNext(MeasurementDatabase measurementDatabase)
                            {
                            }

                            @Override
                            public void onError(Throwable e) {

                            }

                            @Override
                            public void onComplete() {

                            }
                        });

I am getting an error saying:

java.lang.IllegalStateException: Cannot access database on the main thread since it may potentially lock the UI for a long period of time.

What is missing from my RxJava code thats not putting the process on the background thread?

Ehsan Aminifar :

Create an Observable and write your logic inside it. You can subscribe the observable and get the boolean.

 public Observable<Boolean> insertObject(Measurements m) {
    return Observable.create(new ObservableOnSubscribe<Boolean>() {
        @Override
        public void subscribe(ObservableEmitter<Boolean> e) {
            appDb.measurementDAO().insertMeasurements(m);
            e.onNext(true);
            e.onComplete();
        }
    }).subscribeOn(Schedulers.io());            

}