जवाबों:
संपादित :
चूंकि मैं अपने एक आवेदन में इस विशेष विषय में जांच कर रहा हूं, इसलिए मैं इस प्रश्न के भविष्य के पाठकों के लिए एक विस्तारित उत्तर लिख सकता हूं।
एक को लागू करें OnScrollListener, अपने सेट ListViewकी onScrollListenerऔर उसके बाद आप चीजों को सही ढंग से संभाल करने के लिए सक्षम होना चाहिए।
उदाहरण के लिए:
private int preLast;
// Initialization stuff.
yourListView.setOnScrollListener(this);
// ... ... ...
@Override
public void onScroll(AbsListView lw, final int firstVisibleItem,
final int visibleItemCount, final int totalItemCount)
{
switch(lw.getId())
{
case R.id.your_list_id:
// Make your calculation stuff here. You have all your
// needed info from the parameters of this function.
// Sample calculation to determine if the last
// item is fully visible.
final int lastItem = firstVisibleItem + visibleItemCount;
if(lastItem == totalItemCount)
{
if(preLast!=lastItem)
{
//to avoid multiple calls for last item
Log.d("Last", "Last");
preLast = lastItem;
}
}
}
}
listviewहै तो मैं क्या करूं stackFromBottom? मैंने कोशिश की if (0 == firstVisibleItem){//listviewtop}लेकिन वह बार-बार बुला रहा है।
देर से जवाब, लेकिन अगर आप बस यह देखना चाहते हैं कि आपके श्रोता को सभी तरह से नीचे स्क्रॉल किया गया है या नहीं, तो एक इवेंट श्रोता बनाए बिना, आप इस इफ-स्टेटमेंट का उपयोग कर सकते हैं:
if (yourListView.getLastVisiblePosition() == yourListView.getAdapter().getCount() -1 &&
yourListView.getChildAt(yourListView.getChildCount() - 1).getBottom() <= yourListView.getHeight())
{
//It is scrolled all the way down here
}
पहले यह जांचता है कि अंतिम संभावित स्थिति क्या है। फिर यह जांचता है कि अंतिम बटन के नीचे सूची दृश्य के नीचे के साथ संरेखित किया गया है। आप यह जानने के लिए कुछ ऐसा ही कर सकते हैं कि क्या यह सबसे ऊपर है:
if (yourListView.getFirstVisiblePosition() == 0 &&
yourListView.getChildAt(0).getTop() >= 0)
{
//It is scrolled all the way up here
}
getChildCount()है कि व्यूग्रुप में उन विचारों को लौटाता है, जो व्यू रिसाइकलिंग के साथ एडेप्टर में आइटमों की संख्या के समान नहीं हैं। हालाँकि, चूंकि ListView AdapterView से उतरता है, आप getCount()सीधे ListView पर उपयोग कर सकते हैं ।
जिस तरह से मैंने किया:
listView.setOnScrollListener(new AbsListView.OnScrollListener() {
@Override
public void onScrollStateChanged(AbsListView view, int scrollState) {
if (scrollState == AbsListView.OnScrollListener.SCROLL_STATE_IDLE
&& (listView.getLastVisiblePosition() - listView.getHeaderViewsCount() -
listView.getFooterViewsCount()) >= (adapter.getCount() - 1)) {
// Now your listview has hit the bottom
}
}
@Override
public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
}
});
के प्रभाव के लिए कुछ:
if (getListView().getLastVisiblePosition() == (adapter.items.size() - 1))public void onScrollStateChanged(AbsListView view, int scrollState)
{
if (!view.canScrollList(View.SCROLL_AXIS_VERTICAL) && scrollState == SCROLL_STATE_IDLE)
{
//When List reaches bottom and the list isn't moving (is idle)
}
}
इसने मेरे लिए काम किया।
यह हो सकता है
@Override
public void onScrollStateChanged(AbsListView view, int scrollState) {
// TODO Auto-generated method stub
if (scrollState == 2)
flag = true;
Log.i("Scroll State", "" + scrollState);
}
@Override
public void onScroll(AbsListView view, int firstVisibleItem,
int visibleItemCount, int totalItemCount) {
// TODO Auto-generated method stub
if ((visibleItemCount == (totalItemCount - firstVisibleItem))
&& flag) {
flag = false;
Log.i("Scroll", "Ended");
}
}
स्क्रॉलिंग से निपटने के लिए यह बहुत दर्दनाक था, यह पता लगाने पर कि यह समाप्त हो गया है और यह वास्तव में सूची के नीचे है (दृश्य स्क्रीन के नीचे नहीं), और वेब से डेटा प्राप्त करने के लिए केवल एक बार मेरी सेवा चलाता है। हालाँकि यह अब ठीक काम कर रहा है। कोड किसी भी लाभ के लिए निम्नानुसार है जो समान स्थिति का सामना करता है।
नोट: मुझे अपने एडॉप्टर से संबंधित कोड को ऑन व्यू में स्थानांतरित करना था और ऑनक्रिएट के बजाय मुख्य रूप से स्क्रॉलिंग का पता लगाना था:
public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {}
public void onScrollStateChanged(AbsListView view, int scrollState) {
if (getListView().getLastVisiblePosition() == (adapter.getCount() - 1))
if (RideListSimpleCursorAdapter.REACHED_THE_END) {
Log.v(TAG, "Loading more data");
RideListSimpleCursorAdapter.REACHED_THE_END = false;
Intent intent = new Intent(getActivity().getApplicationContext(), FindRideService.class);
getActivity().getApplicationContext().startService(intent);
}
}यहाँ RideListSimpleCursorAdapter.REACHED_THE_END मेरे SimpleCustomAdapter में एक अतिरिक्त चर है जो इस प्रकार सेट है:
if (position == getCount() - 1) {
REACHED_THE_END = true;
} else {
REACHED_THE_END = false;
}केवल जब ये दोनों स्थितियां मिलती हैं, तो इसका मतलब है कि मैं वास्तव में सूची में सबसे नीचे हूं, और मेरी सेवा केवल एक बार चलेगी। यदि मैं REACHED_THE_END को नहीं पकड़ता, तो भी पीछे की ओर स्क्रॉल करने से सेवा फिर से चालू हो जाती है, जब तक कि अंतिम आइटम देखने में न हो।
canScrollVertically(int direction)सभी दृश्यों के लिए काम करता है, और ऐसा लगता है कि आपने जो पूछा, वह अन्य उत्तरों की तुलना में कम कोड के साथ है। सकारात्मक संख्या में प्लग करें, और यदि परिणाम गलत है, तो आप नीचे हैं।
अर्थात:
if (!yourView.canScrollVertically(1)) {
//you've reached bottom
}
उपरोक्त उत्तरों में से किसी एक पर थोड़ा विस्तार करने के लिए, यह वही है जो मुझे पूरी तरह से काम करने के लिए करना था। ऐसा लगता है कि लिस्ट व्यू के अंदर बिल्ट-इन गद्दी का लगभग 6dp है, और सूची खाली होने पर onScroll () कहा जा रहा था। यह उन दोनों चीजों को संभालता है। यह शायद थोड़ा अनुकूलित किया जा सकता है, लेकिन स्पष्टता के लिए अधिक लिखा जाता है।
साइड नोट: मैंने पिक्सेल रूपांतरण तकनीकों में कई अलग-अलग डीपी की कोशिश की है, और यह डीपी 2 पीएक्स () सबसे अच्छा रहा है।
myListView.setOnScrollListener(new OnScrollListener() {
public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
if (visibleItemCount > 0) {
boolean atStart = true;
boolean atEnd = true;
View firstView = view.getChildAt(0);
if ((firstVisibleItem > 0) ||
((firstVisibleItem == 0) && (firstView.getTop() < (dp2px(6) - 1)))) {
// not at start
atStart = false;
}
int lastVisibleItem = firstVisibleItem + visibleItemCount;
View lastView = view.getChildAt(visibleItemCount - 1);
if ((lastVisibleItem < totalItemCount) ||
((lastVisibleItem == totalItemCount) &&
((view.getHeight() - (dp2px(6) - 1)) < lastView.getBottom()))
) {
// not at end
atEnd = false;
}
// now use atStart and atEnd to do whatever you need to do
// ...
}
}
public void onScrollStateChanged(AbsListView view, int scrollState) {
}
});
private int dp2px(int dp) {
return (int)TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, getResources().getDisplayMetrics());
}मैं अभी तक कोई टिप्पणी नहीं कर सकता क्योंकि मुझे पर्याप्त प्रतिष्ठा नहीं मिली है, लेकिन @ इली इमरान और @Wroclai के उत्तर में मुझे लगता है कि कुछ गायब है। कोड के उस टुकड़े के साथ, एक बार जब आप प्रीलास्ट को अपडेट करते हैं, तो यह लॉग को फिर से निष्पादित नहीं करेगा। मेरी विशिष्ट समस्या में, मैं हर बार नीचे की ओर स्क्रॉल करने पर कुछ ऑपरेशन को निष्पादित करना चाहता हूं, लेकिन एक बार प्रीस्टैस्ट को LastItem में अपडेट करने के बाद, उस ऑपरेशन को फिर से निष्पादित नहीं किया जाता है।
private int preLast;
// Initialization stuff.
yourListView.setOnScrollListener(this);
// ... ... ...
@Override
public void onScroll(AbsListView lw, final int firstVisibleItem,
final int visibleItemCount, final int totalItemCount) {
switch(lw.getId()) {
case android.R.id.list:
// Make your calculation stuff here. You have all your
// needed info from the parameters of this function.
// Sample calculation to determine if the last
// item is fully visible.
final int lastItem = firstVisibleItem + visibleItemCount;
if(lastItem == totalItemCount) {
if(preLast!=lastItem){ //to avoid multiple calls for last item
Log.d("Last", "Last");
preLast = lastItem;
}
} else {
preLast = lastItem;
}}
उस "और" के साथ अब आप अपने कोड (लॉग, इस मामले में) को निष्पादित करने में सक्षम हैं, जब भी आप एक बार फिर से नीचे स्क्रॉल करेंगे।
public void onScroll(AbsListView view, int firstVisibleItem,
int visibleItemCount, int totalItemCount) {
int lastindex = view.getLastVisiblePosition() + 1;
if (lastindex == totalItemCount) { //showing last row
if ((view.getChildAt(visibleItemCount - 1)).getTop() == view.getHeight()) {
//Last row fully visible
}
}
}आपकी सूची को कॉल करने के लिए जब सूची अंतिम तक पहुंच जाती है और यदि कोई त्रुटि होती है, तो यह एंडोफिल्टरव्यू को फिर से कॉल नहीं करेगा । यह कोड इस परिदृश्य को भी मदद करेगा।
@Override
public void onScroll(AbsListView view, int firstVisibleItem,
int visibleItemCount, int totalItemCount) {
final int lastPosition = firstVisibleItem + visibleItemCount;
if (lastPosition == totalItemCount) {
if (previousLastPosition != lastPosition) {
//APPLY YOUR LOGIC HERE
}
previousLastPosition = lastPosition;
}
else if(lastPosition < previousLastPosition - LIST_UP_THRESHOLD_VALUE){
resetLastIndex();
}
}
public void resetLastIndex(){
previousLastPosition = 0;
}जहां LIST_UP_THRESHOLD_VALUE का पूर्णांक मान हो सकता है (मैंने 5 का उपयोग किया है) जहां आपकी सूची स्क्रॉल की जाती है और अंत में वापस आते समय, यह सूची दृश्य के अंत को फिर से कॉल करेगा।
मुझे अगले पेज सेट को अपने आप लोड करने के लिए एक बहुत अच्छा तरीका मिला है जिसमें आपको अपनी आवश्यकता नहीं है ScrollView(जैसे स्वीकृत उत्तर की आवश्यकता है)।
ParseQueryAdapter पर एक विधि है जिसे कहा जाता है getNextPageViewकि आप अपने स्वयं के कस्टम दृश्य की आपूर्ति करने की अनुमति देते हैं जो सूची के अंत में दिखाई देता है जब लोड करने के लिए अधिक डेटा होता है तो यह केवल तभी ट्रिगर होगा जब आप वर्तमान पृष्ठ सेट के अंत तक पहुँच चुके हों (यह "अधिक लोड है .." डिफ़ॉल्ट रूप से देखें)। इस विधि को केवल तब कहा जाता है जब लोड करने के लिए अधिक डेटा होता है, इसलिए यह कॉल करने के लिए एक शानदार जगह है। loadNextPage(); इस तरह से यह निर्धारित करने के लिए एडेप्टर आपके लिए पूरी मेहनत करता है कि नया डेटा कब लोड किया जाना चाहिए और यदि आपके पास है तो इसे बिल्कुल नहीं कहा जाएगा। डेटा सेट के अंत तक पहुँच गया।
public class YourAdapter extends ParseQueryAdapter<ParseObject> {
..
@Override
public View getNextPageView(View v, ViewGroup parent) {
loadNextPage();
return super.getNextPageView(v, parent);
}
}फिर आपकी गतिविधि / खंड के अंदर आपको बस एडॉप्टर सेट करना होगा और नया डेटा आपके लिए जादू की तरह स्वचालित रूप से अपडेट हो जाएगा।
adapter = new YourAdapter(getActivity().getApplicationContext());
adapter.setObjectsPerPage(15);
adapter.setPaginationEnabled(true);
yourList.setAdapter(adapter);यह पता लगाने के लिए कि क्या अंतिम आइटम पूरी तरह से दिखाई दे रहा है , आप दृश्य के अंतिम दृश्य आइटम के तल पर गणना को सरल जोड़ सकते हैं lastItem.getBottom()।
yourListView.setOnScrollListener(this);
@Override
public void onScroll(AbsListView view, final int firstVisibleItem,
final int visibleItemCount, final int totalItemCount) {
int vH = view.getHeight();
int topPos = view.getChildAt(0).getTop();
int bottomPos = view.getChildAt(visibleItemCount - 1).getBottom();
switch(view.getId()) {
case R.id.your_list_view_id:
if(firstVisibleItem == 0 && topPos == 0) {
//TODO things to do when the list view scroll to the top
}
if(firstVisibleItem + visibleItemCount == totalItemCount
&& vH >= bottomPos) {
//TODO things to do when the list view scroll to the bottom
}
break;
}
}मैं के साथ गया:
@Override
public void onScroll(AbsListView listView, int firstVisibleItem, int visibleItemCount, int totalItemCount)
{
if(totalItemCount - 1 == favoriteContactsListView.getLastVisiblePosition())
{
int pos = totalItemCount - favoriteContactsListView.getFirstVisiblePosition() - 1;
View last_item = favoriteContactsListView.getChildAt(pos);
//do stuff
}
}विधि getView()(एक- BaseAdapterश्रेणी वाले वर्ग) में यह जांच सकता है कि क्या वर्तमान दृश्य की स्थिति में मदों की सूची के बराबर है Adapter। अगर ऐसा है, तो इसका मतलब है कि हम सूची के अंत / तल पर पहुँच गए हैं:
@Override
public View getView(int position, View convertView, ViewGroup parent) {
// ...
// detect if the adapter (of the ListView/GridView) has reached the end
if (position == getCount() - 1) {
// ... end of list reached
}
}लिस्टव्यू स्क्रॉल एंड का पता लगाने के लिए मैं एक बेहतर तरीका ढूंढता हूं, पहले इस सूची के कार्यान्वयन द्वारा स्कोल एंड
का पता लगाएं। एक सूची में स्क्रॉलिंग के अंत का पता लगाने के लिए ऑनर्सक्रोलिस्टनर का कार्यान्वयन
public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
this.currentFirstVisibleItem = firstVisibleItem;
this.currentVisibleItemCount = visibleItemCount;
}
public void onScrollStateChanged(AbsListView view, int scrollState) {
this.currentScrollState = scrollState;
this.isScrollCompleted();
}
private void isScrollCompleted() {
if (this.currentVisibleItemCount > 0 && this.currentScrollState == SCROLL_STATE_IDLE) {
/*** In this way I detect if there's been a scroll which has completed ***/
/*** do the work! ***/
}
}अंत में मार्टिज़न के उत्तर को मिलाएं
OnScrollListener onScrollListener_listview = new OnScrollListener() {
private int currentScrollState;
private int currentVisibleItemCount;
@Override
public void onScrollStateChanged(AbsListView view, int scrollState) {
// TODO Auto-generated method stub
this.currentScrollState = scrollState;
this.isScrollCompleted();
}
@Override
public void onScroll(AbsListView lw, int firstVisibleItem,
int visibleItemCount, int totalItemCount) {
// TODO Auto-generated method stub
this.currentVisibleItemCount = visibleItemCount;
}
private void isScrollCompleted() {
if (this.currentVisibleItemCount > 0 && this.currentScrollState == SCROLL_STATE_IDLE) {
/*** In this way I detect if there's been a scroll which has completed ***/
/*** do the work! ***/
if (listview.getLastVisiblePosition() == listview.getAdapter().getCount() - 1
&& listview.getChildAt(listview.getChildCount() - 1).getBottom() <= listview.getHeight()) {
// It is scrolled all the way down here
Log.d("henrytest", "hit bottom");
}
}
}
};Stackoverflow में पोस्टर के लिए बड़ा धन्यवाद! मैंने कुछ विचारों को संयोजित किया और गतिविधियों और अंशों के लिए वर्ग श्रोता बनाया (इसलिए यह कोड लिखने के लिए और पुन: लिखने के लिए और अधिक क्लीनर बनाने के लिए पुन: प्रयोज्य बनाने वाला कोड है)।
आपको केवल तब करना है जब आपको मेरी कक्षा मिल गई है इंटरफ़ेस लागू करने के लिए (और निश्चित रूप से इसके लिए विधि बनाएं) जो कि मेरी कक्षा में घोषित की गई है और इस कक्षा पास करने वाले तर्कों का उद्देश्य बनाएं।
/**
* Listener for getting call when ListView gets scrolled to bottom
*/
public class ListViewScrolledToBottomListener implements AbsListView.OnScrollListener {
ListViewScrolledToBottomCallback scrolledToBottomCallback;
private int currentFirstVisibleItem;
private int currentVisibleItemCount;
private int totalItemCount;
private int currentScrollState;
public interface ListViewScrolledToBottomCallback {
public void onScrolledToBottom();
}
public ListViewScrolledToBottomListener(Fragment fragment, ListView listView) {
try {
scrolledToBottomCallback = (ListViewScrolledToBottomCallback) fragment;
listView.setOnScrollListener(this);
} catch (ClassCastException e) {
throw new ClassCastException(fragment.toString()
+ " must implement ListViewScrolledToBottomCallback");
}
}
public ListViewScrolledToBottomListener(Activity activity, ListView listView) {
try {
scrolledToBottomCallback = (ListViewScrolledToBottomCallback) activity;
listView.setOnScrollListener(this);
} catch (ClassCastException e) {
throw new ClassCastException(activity.toString()
+ " must implement ListViewScrolledToBottomCallback");
}
}
@Override
public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
this.currentFirstVisibleItem = firstVisibleItem;
this.currentVisibleItemCount = visibleItemCount;
this.totalItemCount = totalItemCount;
}
@Override
public void onScrollStateChanged(AbsListView view, int scrollState) {
this.currentScrollState = scrollState;
if (isScrollCompleted()) {
if (isScrolledToBottom()) {
scrolledToBottomCallback.onScrolledToBottom();
}
}
}
private boolean isScrollCompleted() {
if (this.currentVisibleItemCount > 0 && this.currentScrollState == SCROLL_STATE_IDLE) {
return true;
} else {
return false;
}
}
private boolean isScrolledToBottom() {
System.out.println("First:" + currentFirstVisibleItem);
System.out.println("Current count:" + currentVisibleItemCount);
System.out.println("Total count:" + totalItemCount);
int lastItem = currentFirstVisibleItem + currentVisibleItemCount;
if (lastItem == totalItemCount) {
return true;
} else {
return false;
}
}
}आपको अपनी सूची दृश्य में एक खाली xml पाद लेख संसाधन जोड़ना होगा और पता लगाना होगा कि क्या यह पाद दिखाई दे रहा है।
private View listViewFooter;
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
View rootView = inflater.inflate(R.layout.fragment_newsfeed, container, false);
listView = (CardListView) rootView.findViewById(R.id.newsfeed_list);
footer = inflater.inflate(R.layout.newsfeed_listview_footer, null);
listView.addFooterView(footer);
return rootView;
}फिर अपने listView स्क्रॉल श्रोता में आप यह करते हैं
@
Override
public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
if (firstVisibleItem == 0) {
mSwipyRefreshLayout.setDirection(SwipyRefreshLayoutDirection.TOP);
mSwipyRefreshLayout.setEnabled(true);
} else if (firstVisibleItem + visibleItemCount == totalItemCount) //If last row is visible. In this case, the last row is the footer.
{
if (footer != null) //footer is a variable referencing the footer view of the ListView. You need to initialize this onCreate
{
if (listView.getHeight() == footer.getBottom()) { //Check if the whole footer is visible.
mSwipyRefreshLayout.setDirection(SwipyRefreshLayoutDirection.BOTTOM);
mSwipyRefreshLayout.setEnabled(true);
}
}
} else
mSwipyRefreshLayout.setEnabled(false);
}यदि आप सूची के अंतिम आइटम के दृश्य पर एक टैग सेट करते हैं, तो बाद में आप टैग के साथ दृश्य को पुनः प्राप्त कर सकते हैं, यदि दृश्य शून्य है क्योंकि दृश्य अब लोड नहीं है। ऐशे ही:
private class YourAdapter extends CursorAdapter {
public void bindView(View view, Context context, Cursor cursor) {
if (cursor.isLast()) {
viewInYourList.setTag("last");
}
else{
viewInYourList.setTag("notLast");
}
}
}फिर यदि आपको यह जानना आवश्यक है कि क्या अंतिम वस्तु भरी हुई है
View last = yourListView.findViewWithTag("last");
if (last != null) {
// do what you want to do
}Janwilx72 सही है, लेकिन यह मिनट है एसडीके 21 है, इसलिए मैं इस विधि को बनाता हूं is
private boolean canScrollList(@ScrollOrientation int direction, AbsListView listView) {
final int childCount = listView.getChildCount();
if (childCount == 0) {
return false;
}
final int firstPos = listView.getFirstVisiblePosition();
final int paddingBottom = listView.getListPaddingBottom();
final int paddingTop = listView.getListPaddingTop();
if (direction > 0) {
final int lastBottom = listView.getChildAt(childCount - 1).getBottom();
final int lastPos = firstPos + childCount;
return lastPos < listView.getChildCount() || lastBottom > listView.getHeight() - paddingBottom;
} else {
final int firstTop = listView.getChildAt(0).getTop();
return firstPos > 0 || firstTop < paddingTop;
}
}स्क्रॉल के लिए:
protected static final int SCROLL_UP = -1;
protected static final int SCROLL_DOWN = 1;
@Retention(RetentionPolicy.SOURCE)
@IntDef({SCROLL_UP, SCROLL_DOWN})
protected @interface Scroll_Orientation{}शायद देर से ही सही, देर से आने वालों के लिए late
यदि आप अपनी सूची के साथ एक कस्टम एडाप्टर का उपयोग कर रहे हैं (ज्यादातर लोग करते हैं!) एक सुंदर समाधान यहां दिया गया है!
https://stackoverflow.com/a/55350409/1845404
जब सूची को अंतिम आइटम पर स्क्रॉल किया जाता है तो एडेप्टर का getView विधि पता लगाती है। यह दुर्लभ समय के लिए भी सुधार जोड़ता है जब कुछ पहले की स्थिति को तब भी कहा जाता है जब एडॉप्टर पहले ही अंतिम दृश्य प्रदान कर चुका हो।
मैंने वह किया और मेरे लिए काम किया:
private void YourListView_Scrolled(object sender, ScrolledEventArgs e)
{
double itemheight = YourListView.RowHeight;
double fullHeight = YourListView.Count * itemheight;
double ViewHeight = YourListView.Height;
if ((fullHeight - e.ScrollY) < ViewHeight )
{
DisplayAlert("Reached", "We got to the end", "OK");
}
}यह आपकी सूची को अंतिम प्रविष्टि तक स्क्रॉल करेगा।
ListView listView = new ListView(this);
listView.setLayoutParams(new LayoutParams(LayoutParams.FILL_PARENT,LayoutParams.FILL_PARENT));
listView.setTranscriptMode(ListView.TRANSCRIPT_MODE_ALWAYS_SCROLL);
listView.setStackFromBottom(true);