path: root/src/plugins/android.codeutils/templates/activity_samples/endless_list_pull_to_refresh/pull_to_refresh_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.Calendar;
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.text.format.DateFormat;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnTouchListener;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.ProgressBar;
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;

	/**
	 * The list header (Where is the loading and last updated labels)
	 */
	private LinearLayout listHeader = null;

	/**
	 * Last loaded item
	 */
	private TextView lastUpdated = null;

	/**
	 * Loading progress
	 */
	private ProgressBar loadingProgress = null;

	/**
	 * Just an integer to add items sequentially
	 */
	private int lastAdded = 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 = 2;

	/**
	 * 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";

	/**
	 * Property to save the time of the last update
	 */
	private static final String PROP_LAST_UPDATED = "last_updated";

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

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

		listHeader = (LinearLayout) getLayoutInflater().inflate(
				R.layout.#layout_name#endless_list_pull_to_refresh/listheader.xml#, null);
		getListView().addHeaderView(listHeader);
		lastUpdated = (TextView) listHeader.findViewById(R.id.lastUpdated);
		loadingProgress = (ProgressBar) listHeader
				.findViewById(R.id.progressBar);
		loadingProgress.setVisibility(View.GONE);
		lastUpdated.setText(R.string.last_updated);
		lastUpdated.setText(lastUpdated.getText().toString() + DateFormat.format("EEEE, MMMM dd, yyyy",
				Calendar.getInstance()));
		if (savedInstanceState == null
				|| (savedInstanceState != null && savedInstanceState.getInt(
						PROP_ITEM_COUNT, 0) == 0)) {
			// download asynchronously initial list
			Downloaditems downloadAction = new Downloaditems();
			downloadAction.execute(new Integer[] { BLOCK_SIZE });
		}

		setListAdapter(arrayAdapter);
		getListView().setOnTouchListener(new PullEventListener());
	}

	@Override
	protected void onSaveInstanceState(Bundle outState) {
		/*
		 * Save instance loaded items to be restored after rotate the device OR
		 * after you have pressed home button
		 */
		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());
		outState.putString(PROP_LAST_UPDATED, lastUpdated.getText().toString());
		super.onSaveInstanceState(outState);
	}

	@Override
	protected void onRestoreInstanceState(Bundle state) {
		/*
		 * Restore state. Also restore lastAdded value since this class is a new
		 * instance on restore
		 */
		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)));
		}
		lastAdded = count;
		getListView().setSelection(state.getInt(PROP_TOP_ITEM));
		lastUpdated.setText(state.getString(PROP_LAST_UPDATED));
	}

	@Override
	protected void onListItemClick(ListView lv, View v, int position, long id) {
	    int listIndex = position - 1;
	    if (arrayAdapter.getItemAt(listIndex) != null) {
	        //your action here
            Toast.makeText(
                    lv.getContext(),
                    getString(R.string.selected_element_message,
                            arrayAdapter.getItemAt(listIndex).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(int numberOfItemsToBeCreated) {
		List<ListElement> results = new ArrayList<ListElement>();
		try {
			// wait for 2 seconds in order to simulate the long service
			Thread.sleep(2000);
			// create items
			for (int i = 0; i <= numberOfItemsToBeCreated; i++) {
			    String itemToBeAdded = getString(R.string.list_item_number,
                        (lastAdded++));
				results.add(new ListElement(itemToBeAdded, R.drawable.#drawable_name#endless_list_pull_to_refresh/listicon.png#));
			}
		} 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.
	 */

	/**
	 * 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 NUMBER_OF_ITEMS_TO_BE_CREATED_INDEX = 0;

		@Override
		protected void onPreExecute() {
			// flag loading is being executed
			isLoading = true;
			loadingProgress.setVisibility(View.VISIBLE);
			lastUpdated.setText(R.string.loading_message);
		}

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

			// execute the long service
			return retrieveItems(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)) {
						// Add items always in the beginning
						arrayAdapter.insert(item, 0);
					}
				}
			}
			
			loadingProgress.setVisibility(View.GONE);
			lastUpdated.setText(getString(R.string.last_updated,
			        DateFormat.format("EEEE, MMMM dd, yyyy",
                    Calendar.getInstance())));
			// 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 index < items.size() ? items.get(index) : null;
		}

		@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);

			return rowView;
		}
	}

	class PullEventListener implements OnTouchListener {

        private float firstEventY;
		private CharSequence previousLastUpdatedText;
		private boolean shouldConsiderRefresh = false;

        @Override
        public boolean onTouch(View v, MotionEvent event) {
            switch (event.getAction()) {
            // Save the first touch position
            case MotionEvent.ACTION_DOWN:
                shouldConsiderRefresh = getListView().getFirstVisiblePosition() == 0
                        && listHeader.getTop() == 0;
                previousLastUpdatedText = lastUpdated.getText();
                if (shouldConsiderRefresh) {
                    firstEventY = event.getY();
                }
                break;

            // Check if we can refresh with certain delta to update texts
            case MotionEvent.ACTION_MOVE:
                if (shouldConsiderRefresh) {
                    float currentEventY = event.getY();
                    if (currentEventY != firstEventY) {
                        lastUpdated.setText(R.string.pull_to_refresh);
                    }
                    if (shouldRefresh(firstEventY, currentEventY) && !isLoading) {
                        lastUpdated.setText(R.string.release_to_refresh);
                    }
                }
                break;

            // Check if we can refresh with certain delta and go back to the
            // original text because the touch event is finished
            case MotionEvent.ACTION_UP:
                lastUpdated.setText(previousLastUpdatedText);
                if (shouldConsiderRefresh) {
                    float currentEventY = event.getY();
                    if (shouldRefresh(firstEventY, currentEventY) && !isLoading) {
                        lastUpdated.setText(previousLastUpdatedText);
                        Downloaditems downloadAction = new Downloaditems();
                        downloadAction.execute(new Integer[] { BLOCK_SIZE });
                        event.setAction(MotionEvent.ACTION_CANCEL);
                        dispatchTouchEvent(event);
                        shouldConsiderRefresh = false;
                        return true;
                    }
                }
                break;
            }
            return false;
        }

        /**
         * Check if the difference between first and current touch positions are
         * enough to dispatch a refresh
         * 
         * @param firstTapPosition
         * @param currentPosition
         * @return true if the difference is big enough to refresh, false otherwise
         */
        private boolean shouldRefresh(float firstTapPosition,
                float currentPosition) {
            int threshold = getListView().getHeight() / 4;
            return ((currentPosition - firstTapPosition) / 2) > threshold;
        }

    }
}