Background
I have multiple ways to get data from server, such as background polling and server push. These items may be contain same item.when data is ready, I insert these data into database with Android Room. when the insert item have exist in database, I will abort the item. I expect to get notify when these data insert success, so I use livedata in the Dao:
#Dao
public interface WordDao {
#Query("SELECT * from word_table where isNew = 0")
LiveData<List<Word>> getAlphabetizedWords();
#Insert
void insert(List<Word> word);
#Update
void update(List<Word> words);
}
In the application code:
#Override
public void onCreate() {
super.onCreate();
wordRepository = WordRepository.getInstance(this);
wordRepository.getAllWords().observeForever(new DatabaseObserver(this));
}
In the DatabaseObserver, I receive data change notify. I will handle these data, then I will set one property of the class(set isNew = 1) to indicate that the item has been handled. At the same time, that handle keep the later insert will not notify old insert data.
My Question
Is this pattern using observeForever() will be worked as expect?
When I write the demo code, I encounter that the DatabaseObserver's onChanged method receive same item list. After I change my code like this, the problem is still there. How to resolve this problem?
Related
Im building an app following architecture guidelines.Implemented room db caching + network.Need to get latest page number from separate entity.
My model:
#Entity(tableName = "top_rated_movie_page")
public class Top_Rated_Movies_Page {
#PrimaryKey(autoGenerate = true)
private int db_id;
private Integer page;
private Integer total_results;
private Integer total_pages;
#Ignore
private List<Result> results;
...
Result class contains data which i display in my paged list which observes changes from db.
Using PagedList.BoundaryCallback i need to fetch new data from network and insert it into db.
But i need to get page number somehow.
My dao:
#Insert
void insertAll(Top_Rated_Movies_Page page,List<Result> top_rated_results);
#Query("SELECT * FROM Result")
DataSource.Factory<Integer, Result> getAllResults();
#Query("SELECT * FROM top_rated_movie_page WHERE page= (SELECT MAX(page) FROM top_rated_movie_page)")
LiveData<Top_Rated_Movies_Page> getMoviePage();
I was thinking to observe Top_Rated_Movies_Page from db in my repository class with observeForever() to get that page number.
Is that the best way to approach this?
Since the only time you'll read the next page key or update the backing DB is through BoundaryCallback, you can just read / write your next page key directly.
So in your onItemAtEndLoad() implementation you want something like:
String nextMoviePage = db.runInTransaction(() -> {
movieDao.nextRemoteKey().key;
});
// Make sure not to run on main thread
MovieNetworkResponse response = networkApi.fetchNextMoviePage(remoteKey);
db.runInTransaction(() -> {
movieDao.clearAll(); // Remove previous key
movieDao.insertKey(RemoteKey(response.nextPageKey)); // Insert new key
movieDao.insertAll(response.movies); // Update DataSource + invalidate()
});
Your DAO:
#Insert
void insertAll(List<Result> top_rated_results);
#Query("SELECT * FROM Result")
DataSource.Factory<Integer, Result> getAllResults();
#Query("SELECT * FROM result_key LIMIT 1")
String nextRemoteKey();
#Insert
void insertKey(RemoteKey remoteKey);
And don't forget to clear out both the items and remoteKey whenever you expect to refresh the data!
In the case where you want to keep track of different keys for query, you can simply add that column to your RemoteKey entity.
FYI: Paging2 has been superseded by Paging3 (though just launched alpha01), here is the similar Paging3 sample which solves exactly your use-case: https://github.com/android/architecture-components-samples/blob/master/PagingWithNetworkSample/app/src/main/java/com/android/example/paging/pagingwithnetwork/reddit/repository/inDb/PageKeyedRemoteMediator.kt
I have a problem with room (my fist time with room).
I can insert some data in my DB but not retrieve something. I'm stuck with this problem. If you can explain me.
I explain :
I use Android Architecture Components. So I have an DAO to make my SQL requests. I have a repository to not handle my DB directly.
And finally, I have a viewModel to be not worry by the data persistance.
My DAO uses the annotation #Insert to create a row .
I use Stetho to look through my DB and everything is oK.
My row is created.
So, When I want to get it with another SQL request (by the same way DAO => repository =>ViewModel),
my request returns always null.
// --- DAO ---
#Query("SELECT * FROM users WHERE id = :id")
LiveData<RealEstate> getRealEstate(long id);
// --- REPOSITORY ---
private final RealEstateDao realEstateDao;
public RealEstateRepository(RealEstateDao realEstateDao) { this.realEstateDao = realEstateDao; }
public LiveData<RealEstate> getRealEstate(long id) { return this.realEstateDao.getRealEstate(id); }
// --- VIEWMODEL ---
public LiveData<RealEstate> getUser(long userId) {
return userDataSource.getRealEstate(userId);
}
I think that you are using incorrectly LiveData, Room have bridge adapter for RXJava/Kotlin, Coroutines, etc.
First, change the return value to something like this
#Query("SELECT * FROM users WHERE id = :id")
RealEstate getRealEstate(long id);
Remember that you cannot make database operations in the Main Thread, you should be using a mechanism for that RX, Coroutines, threads, etc.
After this, you can use LiveData in your viewmodel wrapping the data retrieved from your database to notify their UI parent.
I am learning Mvvm pattern in android, and I don't understand one thing. How Live Data knows when data has changed in Room Database? I have this code:
Fragment:
newUserViewModel.getListItemById(itemId).observe(this, new Observer<User>() {
#Override
public void onChanged(#Nullable User user) {
tv.setText(user.getName());
}
});
View model:
public LiveData<User> getListItemById(String itemId){
return repository.getListItem(itemId);
}
Repository:
public LiveData<User> getListItem(String itemId){
return userDao.getUSerByID(itemId);
}
DAO:
#Query("SELECT * FROM User WHERE itemId = :itemId")
LiveData<User> getUSerByID(String itemId);// When this query gets executed and how live Data knows that our Table is changed?
let's say we inserted new User in Database. When is #Query("SELECT * FROM User WHERE itemId = :itemId") gets executed when there is new data in our database?) and How LiveData knows that we have new User in table and callback Observer owner that data has changed?
After diving in the Android Room code, I found out some things:
Room annotation processor generates code from Room annotations (#Query, #Insert...) using javapoet library
Depending on the result type of the query (QueryMethodProcessor), it uses a "binder" or another one. In the case of LiveData, it uses LiveDataQueryResultBinder.
LiveDataQueryResultBinder generates a LiveData class that contains a field _observer of type InvalidationTracker.Observer, responsible of listen to database changes.
Then, basically, when there is any change in the database, LiveData is invalidated and client (your repository) is notified.
Add to your Dao a query to be used just for notifications, something like:
#Query("SELECT * FROM my_table")
public LiveData<List<MyItem>> changeNotif();
and then in your activity listen to changes like this:
LiveData<List<MyItem>> items = AppDatabase.getAppDatabase().itemDao().changeNotif();
items.observe(this, new Observer<List<MyItem>>() {
#Override
public void onChanged(List<MyItem> myItems) {
}
});
I am using Android LiveData and Room Database to update a list.
I have a list of notes which have a tick to mark them as "DONE".
If they are marked done, I remove them from current list (not from database) so that they can be shown on another page.
But marking them done does not update my list.
DAO:
#Dao
public interface NoteDao {
#Query("SELECT * FROM notes WHERE isDone=0")
LiveData<List<Note>> getAll();
#Insert
void insert(Note note);
#Delete
void delete(Note note);
#Update
void update(Note note);
}
I have a onchecked listener in my adapter which handles the list clicks.
Note note = allNotes.get(position);
holder.mCheckBox.setListener(isChecked -> {
note.setIsDone(1);
mNoteDao.update(note);
notifyDataSetChanged();
});
I have put an observe function in activity.
mNoteDao.getAll().observe(this, notes -> {
if (notes != null && notes.size() > 0) {
img_no_notes.setVisibility(View.GONE);
txt_no_notes.setVisibility(View.GONE);
Collections.reverse(notes);
mAdapter.setItems(notes);
} else {
img_no_notes.setVisibility(View.VISIBLE);
txt_no_notes.setVisibility(View.VISIBLE);
}
});
The list is updated on relaunch.
Thanks for your help.
Your LiveData is responsible for reacting to Room database change only. If you want to change the list you need to create separate list or live data copy. Overall it is bad practice and LiveData+Room is used only for database change not memory instance. Imagine your LiveData object like a wrap over Room database.
Your notes probably don't update themselves because your activity didn't change state. In that case you should update UI of changed note in your checkbox listener
From documentation:
LiveData takes in an observer and notifies it about data changes only when it is in STARTED or RESUMED state.
From what i have read Room doesn’t allow you to issue database queries on the main thread (as can cause delays on the main thread)). so imagine i am trying to update a textview on the UI main thread which some data how would i get a call back. Let me show you an example. Imagine i want to store my business model data into a object called Events. We would therefore have a EventDao object:
imagine we have this DAO object below:
#Dao
public interface EventDao {
#Query("SELECT * FROM " + Event.TABLE_NAME + " WHERE " + Event.DATE_FIELD + " > :minDate" limit 1)
LiveData<List<Event>> getEvent(LocalDateTime minDate);
#Insert(onConflict = REPLACE)
void addEvent(Event event);
#Delete
void deleteEvent(Event event);
#Update(onConflict = REPLACE)
void updateEvent(Event event);
}
and now in some activity i have a textview and i'd like to update its value so i do this:
myTextView.setText(EventDao.getEvent(someDate));/*i think this is illegal as im trying to call room dao on mainthread, therefore how is this done correctly ? would i need to show a spinner while it updates ?*/
since the fetching is occuring off of the main thread i dont think i can call it like this and expect a smooth update. Whats the best approach here ?
Some more information: i wanted to use the room database as mechanism for retrieving model information instead of keeping it statically in memory. so the model would be available to me locally through the db after i download it through a rest service.
UPDATE: so since i am returning a livedata then i can do this:
eventDao = eventDatabase.eventDao();
eventDao.getEvent().observe(this, event -> {
myTextView.setText(event.get(0));
});
and that works for something very small. but imagine my database has a million items. then when i do this call, there will be a delay retrieving the data. The very first time this gets called it will be visible to the user that there is a delay. How to avoid this ? So to be clear , there are times i do not want live data, i just need to update once the view. I need to know how to do this ? even if its not with liveData.
If you want to do your query synchronously and not receive notifications of updates on the dataset, just don't wrap you return value in a LiveData object. Check out the sample code from Google.
Take a look at loadProductSync() here
There is a way to turn off async and allow synchronous access.
when building the database you can use :allowMainThreadQueries()
and for in memory use: Room.inMemoryDatabaseBuilder()
Although its not recommended. So in the end i can use a in memory database and main thread access if i wanted super fast access. i guess it depends how big my data is and in this case is very small.
but if you did want to use a callback.... using rxJava here is one i made for a list of countries i wanted to store in a database:
public Observable<CountryModel> queryCountryInfoFor(final String isoCode) {
return Observable.fromCallable(new Callable<CountryModel>() {
#Override
public CountryModel call() throws Exception {
return db.countriesDao().getCountry(isoCode);
}
}).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread());
}
you can then easily add a subscriber to this function to get the callback with Rxjava.
As Bohsen suggested use livedata for query synchronously. But in some special case, we want to do some asynchronous operation based on logic.
In below example case, I need to fetch some child comments for the parent comments. It is already available in DB, but need to fetch based on its parent_id in recyclerview adapter. To do this I used return concept of AsyncTask to get back the result. (Return in Kotlin)
Repositor Class
fun getChildDiscussions(parentId: Int): List<DiscussionEntity>? {
return GetChildDiscussionAsyncTask(discussionDao).execute(parentId).get()
}
private class GetChildDiscussionAsyncTask constructor(private val discussionDao: DiscussionDao?): AsyncTask<Int, Void, List<DiscussionEntity>?>() {
override fun doInBackground(vararg params: Int?): List<DiscussionEntity>? {
return discussionDao?.getChildDiscussionList(params[0]!!)
}
}
Dao Class
#Query("SELECT * FROM discussion_table WHERE parent_id = :parentId")
fun getChildDiscussionList(parentId: Int): List<DiscussionEntity>?
Well, the right answer is to use ListenableFuture or Observable depending if you need one shot query or a new value emitted after database change and the framework you want to use.
From the doc "To prevent queries from blocking the UI, Room does not allow database access on the main thread. This restriction means that you must make your DAO queries asynchronous. The Room library includes integrations with several different frameworks to provide asynchronous query execution."
Exemple with a one shot query. You just have to add this in your gradle file.
// optional - Guava support for Room, including Optional and ListenableFuture
implementation "androidx.room:room-guava:$room_version"
Then your SQL query in your DAO become.
#Query("SELECT * FROM " + Event.TABLE_NAME)
ListenableFuture<List<Event>> getEventList();
Last step is the future call itself.
ListenableFuture<List<Event>> future = dao.getEventList();
future.addListener(new Runnable() {
#Override
public void run() {
try {
List<Event>> result = future.get();
} catch (ExecutionException | InterruptedException e) {
}
}
}, Executors.newSingleThreadExecutor());
Source : https://developer.android.com/training/data-storage/room/async-queries#guava-livedata