How do you know if your ListView has enough number of items so that it can scroll?
For instance, If I have 5 items on my ListView all of it will be displayed on a single screen. But if I have 7 or more, my ListView begins to scroll. How do I know if my List can scroll programmatically?
Diegosan's answer cannot differentiate when the last item is partially visible on the screen. Here is a solution to that problem.
First, the ListView must be rendered on the screen before we can check if its content is scrollable. This can be done with a ViewTreeObserver:
ViewTreeObserver observer = listView.getViewTreeObserver();
observer.addOnGlobalLayoutListener(new OnGlobalLayoutListener() {
@Override
public void onGlobalLayout() {
if (willMyListScroll()) {
// Do something
}
}
});
And here is willMyListScroll():
boolean willMyListScroll() {
int pos = listView.getLastVisiblePosition();
if (listView.getChildAt(pos).getBottom() > listView.getHeight()) {
return true;
} else {
return false;
}
}
As per my comment on Mike Ortiz' answer, I believe his answer is wrong:
getChildAt() only counts the children that are visible on screen. Meanwhile, getLastVisiblePosition returns the index based on the Adapter. So if the lastVisiblePosition is 8 because it's the 9th item in the list and there are only 4 visible items on screen, you're gonna get a crash. Verify it by calling getChildCount() and see. The indices for getChildAt are not the same as the indices for the data set. Check this out: ListView getChildAt returning null for visible children
Here's my solution:
public boolean isScrollable() {
int last = listView.getChildCount()-1; //last visible listitem view
if (listView.getChildAt(last).getBottom()>listView.getHeight() || listView.getChildAt(0).getTop()<0) { //either the first visible list item is cutoff or the last is cutoff
return true;
}
else{
if (listView.getChildCount()==listView.getCount()) { //all visible listitem views are all the items there are (nowhere to scroll)
return false;
}
else{ //no listitem views are cut off but there are other listitem views to scroll to
return true;
}
}
}
You cannot detect this before android render the screen with the listView. However, you can absolutely detect this post-render.
boolean willMyListScroll() {
if(listView.getLastVisiblePosition() + 1 == listView.getCount()) {
return false;
}
return true;
}
What this does is check if the listView visible window contains ALL your list view items. If it can, then the listView will never scroll and the getLastVisiblePosition() will always be equal to the total number of items in the list's dataAdapter.
This is the code I wrote for showing a picture after the last row of the listview:
public class ShowTheEndListview
{
private ImageView the_end_view;
private TabbedFragRootLayout main_layout;
private ListView listView;
private float pas;
private float the_end_img_height;
private int has_scroll = -1;
public ShowTheEndListview(float height)
{
the_end_img_height = height;
pas = 100 / the_end_img_height;
}
public void setData(ImageView the_end_view, TabbedFragRootLayout main_layout, ListView listView)
{
this.the_end_view = the_end_view;
this.main_layout = main_layout;
this.listView = listView;
}
public void onScroll(int totalItemCount)
{
if(totalItemCount - 1 == listView.getLastVisiblePosition())
{
int pos = totalItemCount - listView.getFirstVisiblePosition() - 1;
View last_item = listView.getChildAt(pos);
if (last_item != null)
{
if(listHasScroll(last_item))
{
// Log.e(TAG, "listHasScroll TRUE");
}
else
{
// Log.e(TAG, "listHasScroll FALSE");
}
}
}
}
private boolean listHasScroll(View last_item)
{
if(-1 == has_scroll)
{
has_scroll = last_item.getBottom() > (main_layout.getBottom() - the_end_img_height - 5) ? 1 : 0;
}
return has_scroll == 1;
}
public void resetHasScroll()
{
has_scroll = -1;
}
}
AbsListView includes this:
/**
* Check if the items in the list can be scrolled in a certain direction.
*
* @param direction Negative to check scrolling up, positive to check scrolling down.
* @return true if the list can be scrolled in the specified direction, false otherwise.
* @see #scrollListBy(int)
*/
public boolean canScrollList(int direction);
You need to override layoutChildren() and use it within that:
@Override
protected void layoutChildren() {
super.layoutChildren();
isAtBottom = !canScrollList(1);
isAtTop = !canScrollList(-1);
}
This is how i used to check
if (listView.getAdapter() != null
&& listView.getLastVisiblePosition() == listView.getAdapter().getCount() - 1
&& listView.getChildAt(listView.getChildCount() - 1).getBottom() == listView.getBottom())
if it gives true, then list is at the bottom
Use the setOnScrollListener, by applying the callback to OnScrollListener, you can determine if scrolling is taking place using the pre-defined constants and handle the situation accordingly.
boolean listBiggerThanWindow = appHeight - 50 <= mListView.getHeight();
Toast.makeText(HomeActivity.this, "list view bigger that window? " + listBiggerThanWindow, Toast.LENGTH_LONG)
.show();
if (listBiggerThanWindow) {
// do your thing here...
}
you can get dimensions in onCreate() by calling post(Runnable) on View.
© 2022 - 2024 — McMap. All rights reserved.
wrap_contentheight changes based upon prose). What are you attempting to achieve? – Rafaelof