One of the most utilized UI-elements in Android apps is ListViews. Whether you are displaying a list of songs in an album, ingredients in a recipe, or search results, almost every Android app needs to render lists. Many newer developers are lulled into a false sense of security because it is pretty easy to get started with ListViews.
Checkout more android tutorials at this page : list of best android tutorials.
Understanding View Lifecycles
ListViews often contain more items than can be displayed on a screen at one time. Although the logic of rendering each individual item in the list might be trivial, iterating through all of them is overkill and could lead to serious memory issues. For this reason, ListViews only render what is on screen and slightly off-screen in both directions.
@Override
public View getView(int pos, View recycledView, ViewGroup parent) {
if (recycledView == null) {
recycledView = View.inflate(getActivity(), R.layout.item, parent);
}
...
return recycledView;
}
If you make the mistake of not including this null check and inflate a new view each and every time, your app will have rogue views taking up vital memory. If a user scrolls this list up-and-down enough, it is very likely your app will eventually crash with an out of memory exception.
Cache Your View Data with the View Holder Pattern
Another issue that plagues larger ListViews is the potential for sluggish scrolling when your ListView items take too long to retrieve and/or render their data. Common issues here are items that require non-trivial calculations or database queries to populate. A great approach to solve problems like this is the View Holder pattern. The basic idea is to create a class that can be used to cache the data you have already retrieved or calculated for any future renderings. The following class is a very simplified example of this:
public class MyViewHolder {
TextView difficultToCalculateValue;
...
}
Now, when it comes time to render a ListView item, we start by populating this class. The following getView function provides an example of this:
@Override
public View getView(int pos, View recycledView, ViewGroup parent) {
MyViewHolder myViewHolder;
if (recycledView == null) {
recycledView = View.inflate(getActivity(), R.layout.item, parent);
myViewHolder = new MyViewHolder();
myViewHolder.difficultToCalculateValue = convertView.findViewById(R.id.text_id);
...
recycledView.setTag(myViewHolder);
} else {
myViewHolder = (MyViewHolder)convertView.getTag();
}
myViewHolder.difficultToCalculateValue.setText("This took forever to calculate.");
...
return recycledView;
}
Learning when to use ListView.invalidateViews() and Adapter.notifyDatasetChanged()
invalidatedViews() and notifyDatasetChanged() are two of the main ways to inform your ListView that its child views need to be updated. Some common scenarios of this include handling the removal or addition of a list item, bulk updating the style of list items, or updating the value displayed on several list items.
Properly Handing Asynchronous Tasks
As any Android developer knows, accessing a database or waiting for an API response takes time and should be handled off the main UI-thread. For this reason, neither of these actions should be performed inside your getView functions. A simple solution is to load all of your data into memory prior to rendering your list. If that is not possible, you can enlist the help of AsyncTasks.
The following code snippet shows one example of this. Please note that inline AsyncTasks are typically a bad idea, but one is shown here for the simplicity of the illustration:
@Override
public View getView(int pos, View recycledView, ViewGroup parent) {
...
new AsyncTask() {
@Override
public Bitmap doInBackground(Void... params) {
return BitmapFactory.decodeFile(...);
}
@Override
public void onPostExecute(Bitmap bitmap) {
imageView.setBitmap(bitmap);
}
}.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
return recycledView;
}
It is very likely that your specific implementation will be more involved than this example, but this should help you get started.
Also, keep in mind that you need to ensure your solution can handle users flinging through your ListView. If you spawn a new thread for each item in your list and never cancel them, your app will run into several issues.
Conclusion
Every Android developer will eventually have to create a ListView. Most are fairly simple, but as your lists’ complexity grows, so must your understanding of ListViews. Sluggish ListViews can severely harm your user experience and implementing these tips can go a long way to alleviate these issues. One final thing, it is important to consider all available tools before beginning to code.
If a ListView is not the proper tool for the job, optimizing can only go so far. If you are about to add a ListView to your app, make sure you consider if something else (including the powerful RecyclerView) could be a better fit.
Paul is a Developer Advocate at [The BHW Group]. He works with clients on custom Android apps and web-based solutions. He frequently writes about mobile development, technology, and business-related topics.