no error.

public static LocalRealmDB getInstance() {
    return new LocalRealmDB();
}

//public final int SCHEMA_V_PREV = 0;// previous schema version
public final int SCHEMA_V_NOW = 0;// change schema version if any change happened in schema

private RealmConfiguration configuration;
private Realm realm;

private void initRealConfig() {
    try {
        Realm.init(Application.getInstance());
        if (configuration == null) {
            configuration = new RealmConfiguration.Builder()
                    .schemaVersion(SCHEMA_V_NOW)
                    .name(Parameters.Config.LOCAL_DATABASE_REALM_NAME)
                    .allowWritesOnUiThread(true)
                    .allowQueriesOnUiThread(true)
                    .build();//.migration(new CustomRealmMigrations())//.deleteRealmIfMigrationNeeded()
            Realm.setDefaultConfiguration(configuration);
        }
    } catch (Exception ex) {
        Logger.error(TAG, ex.getMessage());
    }
}

private Realm getRealm() {
    initRealConfig();
    if (realm == null) {
        realm = Realm.getDefaultInstance();
    }
    return realm;
}

private void close() {
    //Yeni bir şemeya geçilecekse kapatılır.
    getRealm().close();
    realm = null;
}

public <T extends RealmObject> void saveData(T dataModel, OnResultListenerAdapter<Boolean> listener) {
    getRealm().executeTransactionAsync(realm -> {
        LogUtil.e("saveData insertOrUpdate dataModel");
        realm.insertOrUpdate(dataModel);
    }, () -> {
        LogUtil.e("saveData onSuccess");
        listener.onSuccess("");
    }, error -> {
        LogUtil.e("saveData error: " + error.getMessage());
        listener.onFail("error: " + error.getMessage());
    });
}

public <T extends RealmObject> void saveDataList(List<T> dataList, OnResultListenerAdapter<String> listener) {
    getRealm().executeTransactionAsync(realm -> {
        //Log.e("RED_LOG", "realm");
        realm.insertOrUpdate(dataList);
    }, () -> {
        LogUtil.e("onSuccess");
        listener.onSuccess("");
        //Log.e("RED_LOG", "success");
    }, error -> {
        //Log.e("RED_LOG", "onError");
        LogUtil.e("error: " + error.getMessage());
        listener.onFail("Save Data List: " + error.getMessage());
    });
}

public <E extends RealmObject> List<E> getDataList(Class<E> clazz) {
    LogUtil.e("getDataList");
    RealmResults<E> models = getRealm().where(clazz).findAll();
    return models;
}

public <E extends RealmObject> int getSize(Class<E> clazz) {
    LogUtil.e("getSize");
    return getRealm().where(clazz).findAll().size();
}

public boolean isEmptyData() {
    LogUtil.e("isEmptyData");
    return getRealm().isEmpty();
}

public <E extends RealmObject> E getData(Class<E> clazz) {
    LogUtil.e("getData");
    return getRealm().where(clazz).findAll().last();
}

public <E extends RealmObject> List<E> getDataListWithFieldName(Class<E> clazz, String id, String fieldName) {
    RealmResults<E> models = getRealm().where(clazz).equalTo(fieldName, id).findAll();
    return models;
}

public <E extends RealmObject> boolean isData(Class<E> clazz) {
    RealmResults<E> models = getRealm().where(clazz).findAll();
    return ControlUtil.isData(models);
}

public <E extends RealmObject> boolean isDataWithId(Class<E> clazz, String employeeId) {
    RealmResults<E> models = getRealm().where(clazz).equalTo("employeeId", employeeId).findAll();
    return !models.isEmpty();
}

public <E extends RealmObject> void deleteDataWithId(Class<E> clazz, String id) {
    LogUtil.e("deleteDataWithId");

    getRealm().executeTransactionAsync(transactionRealm -> {
        E model = transactionRealm.where(clazz).equalTo("id", id).findFirst();
        if (model != null) {
            model.deleteFromRealm();
        }
    });
}

public <E extends RealmObject> void deleteAll(Class<E> clazz, OnResultListenerAdapter<String> listener) {
    LogUtil.e("deleteAll");
    getRealm().executeTransactionAsync(realm -> {
        //Delete All
        realm.where(clazz).findAll().deleteAllFromRealm();
    }, () -> {
        listener.onSuccess("");
    }, error -> {
        listener.onFail(error.getMessage());
    });
}