path: root/src/plugins/android.codeutils/templates/activity_samples/endless_list/endless_list_activity.java

/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package #package_name#;

import java.util.ArrayList;
import java.util.List;
import android.app.Activity;
import android.app.LauncherActivity.ListItem;
import android.app.ListActivity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AbsListView;
import android.widget.AbsListView.OnScrollListener;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.LinearLayout.LayoutParams;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;

import #ManifestPackageName#.R;

/**
 * Class which holds an example of a endless list. It means a list will be
 * displayed and it will always have items to be displayed. <br>
 * New data is loaded asynchronously in order to provide a good user experience.
 */
public class #class_name# extends ListActivity { 

    /**
     * Adapter for endless list.
     */
    private EndlessListAdapter arrayAdapter = null;

    /**
     * Variable which controls when new items start being fetched. For instance
     * you may want to start get element when the list have 5 elements left to
     * be displayed.
     */
    private int totalSizeToBe = 0;

    /**
     * Variable which controls when new items are being loaded. If this variable
     * is true, it means items are being loaded, otherwise it is set to false.
     */
    private boolean isLoading = false;

    /**
     * The number of elements which are retrieved every time the service is
     * called for retrieving elements.
     */
    private static final int BLOCK_SIZE = 15;

    /**
     * The number of elements left in the list when the asynchronous service
     * will be called.
     */
    private static final int LOAD_AHEAD_SIZE = 5;
    
    /**
     * The number of items added to the <i>totalSizeToBe</i> field.
     */
    private static final int INCREMENT_TOTAL_MINIMUM_SIZE = 15;
    
    /**
     * Property to save the number of items already loaded
     */
    private static final String PROP_ITEM_COUNT = "item_count";
    
    /**
     * Property to save the top most index of the list
     */
    private static final String PROP_TOP_ITEM = "top_list_item";

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        arrayAdapter = new EndlessListAdapter(this, R.layout.#layout_name#endless_list/listrow.xml#, new ArrayList<ListElement>());

        // download asynchronously initial list
        Downloaditems downloadAction = new Downloaditems();
        downloadAction.execute(new Integer[] {
                0, BLOCK_SIZE });

        setListAdapter(arrayAdapter);
        getListView().setOnScrollListener(new EndlessListScrollListener());
    }
    
    @Override
    protected void onSaveInstanceState(Bundle outState) {
        outState.putInt(PROP_ITEM_COUNT, arrayAdapter.getCount());
        for (int i = 0; i < arrayAdapter.getCount(); i++) {
            outState.putSerializable(Integer.toString(i),
                    arrayAdapter.getItemAt(i));
        }
        outState.putInt(PROP_TOP_ITEM, getListView().getFirstVisiblePosition());
        super.onSaveInstanceState(outState);
    }

    @Override
    protected void onRestoreInstanceState(Bundle state) {
        super.onRestoreInstanceState(state);
        int count = state.getInt(PROP_ITEM_COUNT);
        for (int i = 0; i < count; i++) {
            arrayAdapter.add((ListElement) state.get(Integer.toString(i)));
        }
        getListView().setSelection(state.getInt(PROP_TOP_ITEM));
    }

    @Override
    protected void onListItemClick(ListView lv, View v, int position, long id) {
        // your action here
        Toast.makeText(
                lv.getContext(),
                getString(R.string.selected_element_message,
                        arrayAdapter.getItemAt(position).text),
                Toast.LENGTH_SHORT).show();
    }

    /**
     * This method represents a service which takes a long time to be executed.
     * To simulate it, it is inserted a lag of 1 second. <br>
     * This method basically creates a <i>cache</i> number of
     * {@link ListElement} and returns it. It creates {@link ListElement}s with
     * text higher than <i>itemNumber</i>.
     * 
     * @param itemNumber
     *            Basic number to create other elements.
     * @param numberOfItemsToBeCreated
     *            Number of items to be created.
     * 
     * @return Returns the created list of {@link ListElement}s.
     */
    private List<ListElement> retrieveItems(Integer itemNumber, int numberOfItemsToBeCreated) {
        List<ListElement> results = new ArrayList<ListElement>();
        try {
            // wait for 1 second in order to simulate the long service
            Thread.sleep(1000);
            // create items
            for (int i = 0; i <= numberOfItemsToBeCreated; i++) {
                String itemToBeAdded = getString(R.string.list_item_number,
                        (itemNumber + i));
                results.add(new ListElement(itemToBeAdded, R.drawable.listicon));
            }
        } catch (InterruptedException e) {
            // treat exception here
        }
        return results;
    }

    /**
     * Listener which handles the endless list. It is responsible for
     * determining when the long service will be called asynchronously.
     */
    class EndlessListScrollListener implements OnScrollListener {

        @Override
        public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount,
                int totalItemCount) {

            // load more elements if there are LOAD_AHEAD_SIZE left in the list to be displayed
            boolean loadMore = firstVisibleItem + visibleItemCount >= totalItemCount
                    - LOAD_AHEAD_SIZE;

            /*
             * Add one more condition: only get more results in case the list achieves
             * a minimum size. This is necessary in order to avoid that this method is called
             * each time the condition above is reached and the scroll is pressed. 
             */
            if (loadMore && totalSizeToBe <= totalItemCount) {
                totalSizeToBe += INCREMENT_TOTAL_MINIMUM_SIZE;
                // call service
                Downloaditems downloadAction = new Downloaditems();
                downloadAction.execute(new Integer[] {
                        totalItemCount, BLOCK_SIZE });
            }
        }

        @Override
        public void onScrollStateChanged(AbsListView view, int scrollState) {
            // do nothing
        }
    }

    /**
     * Asynchronous job call. This class is responsible for calling
     * the long service and managing the <i>isLoading</i> flag.
     */
    class Downloaditems extends AsyncTask<Integer, Void, List<ListElement>> {

        // indexes constants
        private static final int ITEM_NUMBER_INDES = 0;
        private static final int NUMBER_OF_ITEMS_TO_BE_CREATED_INDEX = 1;
        
        @Override
        protected void onPreExecute() {
            // flag loading is being executed
            isLoading = true;
        }

        @Override
        protected List<ListElement> doInBackground(Integer... params) {

            // execute the long service
            return retrieveItems(params[ITEM_NUMBER_INDES], params[NUMBER_OF_ITEMS_TO_BE_CREATED_INDEX]);
        }

        @Override
        protected void onPostExecute(List<ListElement> result) {
            arrayAdapter.setNotifyOnChange(true);
            for (ListElement item : result) {
                // it is necessary to verify whether the item was already added
                // because this job is called many times asynchronously
                synchronized (arrayAdapter) {
                    if (!arrayAdapter.contains(item)) {
                        arrayAdapter.add(item);
                    }
                }
            }
            // flag the loading is finished
            isLoading = false;
        }
    }

    /**
     * Adapter which handles the list be be displayed.
     */
    class EndlessListAdapter extends ArrayAdapter<ListElement> {

        private final Activity context;
        private final List<ListElement> items;
        private final int rowViewId;

        /**
         * Instantiate the Adapter for an Endless List Activity.
         * 
         * @param context {@link Activity} which holds the endless list.
         * @param rowviewId Identifier of the View which holds each row of
         * the List.
         * @param items Initial set of items which are added to list being displayed.
         */
        public EndlessListAdapter(Activity context, int rowviewId, List<ListElement> items) {
            super(context, rowviewId, items);
            this.context = context;
            this.items = items;
            this.rowViewId = rowviewId;
        }

        /**
         * Check whether a {@link ListItem} is already in this adapter.
         * 
         * @param item Item to be verified whether it is in the adapter.
         * 
         * @return Returns <code>true</code> in case the {@link ListElement} is
         * in the adapter, <code>false</code> otherwise.
         */
        public boolean contains(ListElement item) {
            return items.contains(item);
        }
        
        /**
         * Get a {@link ListElement} at a certain position.
         * 
         * @param index Position where the {@link ListElement} is retrieved.
         * 
         * @return Returns the {@link ListElement} give a certain position.
         */
        public ListElement getItemAt(int index) {
            return items.get(index);
        }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {

            ImageView imageView;
            TextView textView;

            View rowView = convertView;
            
            /*
             * We inflate the row using the determined layout. Also,
             * we fill the necessary data in the text and image views. 
             */
            LayoutInflater inflater = context.getLayoutInflater();
            rowView = inflater.inflate(rowViewId, null, true);
            textView = (TextView) rowView.findViewById(R.id.text01);
            imageView = (ImageView) rowView.findViewById(R.id.img01);
            textView.setText(items.get(position).text);
            imageView.setImageResource(items.get(position).imageId);

            /*
             * If we reached the last position of the list and the loading
             * operation is still being performed, set the loading message
             * instead the normal value.
             * 
             * Moreover, we modify the layout in order to center the loading message.
             */
            if (isLoading && position == items.size() - 1) {
                textView.setText(R.string.loading_message);
                
                // wrap content of the text view in order to center it
                LayoutParams layoutParameters = (LayoutParams) textView.getLayoutParams();
                layoutParameters.width = LayoutParams.WRAP_CONTENT;
                
                // set image to the center, the text field will go along
                imageView.setImageResource(android.R.drawable.progress_indeterminate_horizontal);
                LinearLayout linearLayout = (LinearLayout) rowView.findViewById(R.id.vw01);
                linearLayout.setGravity(Gravity.CENTER);
            }

            return rowView;
        }
    }
}