src/com/android/timezonepicker/TimeZoneFilterTypeAdapter.java - platform/frameworks/opt/timezonepicker - Git at Google

 /*
  * Copyright (C) 2013 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 com.android.timezonepicker;

 import android.content.Context;
 import android.text.TextUtils;
 import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.view.ViewGroup;
 import android.widget.BaseAdapter;
 import android.widget.Filter;
 import android.widget.Filterable;
 import android.widget.TextView;

 import java.util.ArrayList;
 import java.util.Collections;

 public class TimeZoneFilterTypeAdapter extends BaseAdapter implements Filterable, OnClickListener {
     public static final String TAG = "TimeZoneFilterTypeAdapter";

     private static final boolean DEBUG = false;

     public static final int FILTER_TYPE_EMPTY = -1;
     public static final int FILTER_TYPE_NONE = 0;
     public static final int FILTER_TYPE_COUNTRY = 1;
     public static final int FILTER_TYPE_STATE = 2;
     public static final int FILTER_TYPE_GMT = 3;

     public interface OnSetFilterListener {
         void onSetFilter(int filterType, String str, int time);
     }

     static class ViewHolder {
         int filterType;
         String str;
         int time;
         TextView strTextView;

         static void setupViewHolder(View v) {
             ViewHolder vh = new ViewHolder();
             vh.strTextView = (TextView) v.findViewById(R.id.value);
             v.setTag(vh);
         }
     }

     class FilterTypeResult {
         int type;
         String constraint;
         public int time;

         public FilterTypeResult(int type, String constraint, int time) {
             this.type = type;
             this.constraint = constraint;
             this.time = time;
         }

         @Override
         public String toString() {
             return constraint;
         }
     }

     private ArrayList<FilterTypeResult> mLiveResults = new ArrayList<FilterTypeResult>();
     private int mLiveResultsCount = 0;

     private ArrayFilter mFilter;

     private LayoutInflater mInflater;

     private TimeZoneData mTimeZoneData;
     private OnSetFilterListener mListener;

     public TimeZoneFilterTypeAdapter(Context context, TimeZoneData tzd, OnSetFilterListener l) {
         mTimeZoneData = tzd;
         mListener = l;
         mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
     }

     @Override
     public int getCount() {
         return mLiveResultsCount;
     }

     @Override
     public FilterTypeResult getItem(int position) {
         return mLiveResults.get(position);
     }

     @Override
     public long getItemId(int position) {
         return position;
     }

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

         if (convertView != null) {
             v = convertView;
         } else {
             v = mInflater.inflate(R.layout.time_zone_filter_item, null);
             ViewHolder.setupViewHolder(v);
         }

         ViewHolder vh = (ViewHolder) v.getTag();

         if (position >= mLiveResults.size()) {
             Log.e(TAG, "getView: " + position + " of " + mLiveResults.size());
         }

         FilterTypeResult filter = mLiveResults.get(position);

         vh.filterType = filter.type;
         vh.str = filter.constraint;
         vh.time = filter.time;
         vh.strTextView.setText(filter.constraint);
         return v;
     }

     OnClickListener mDummyListener = new OnClickListener() {

         @Override
         public void onClick(View v) {
         }
     };

     // Implements OnClickListener

     // This onClickListener is actually called from the AutoCompleteTextView's
     // onItemClickListener. Trying to update the text in AutoCompleteTextView
     // is causing an infinite loop.
     @Override
     public void onClick(View v) {
         if (mListener != null && v != null) {
             ViewHolder vh = (ViewHolder) v.getTag();
             mListener.onSetFilter(vh.filterType, vh.str, vh.time);
         }
         notifyDataSetInvalidated();
     }

     // Implements Filterable
     @Override
     public Filter getFilter() {
         if (mFilter == null) {
             mFilter = new ArrayFilter();
         }
         return mFilter;
     }

     private class ArrayFilter extends Filter {
         @Override
         protected FilterResults performFiltering(CharSequence prefix) {
             if (DEBUG) {
                 Log.d(TAG, "performFiltering >>>> [" + prefix + "]");
             }

             FilterResults results = new FilterResults();
             String prefixString = null;
             if (prefix != null) {
                 prefixString = prefix.toString().trim().toLowerCase();
             }

             if (TextUtils.isEmpty(prefixString)) {
                 results.values = null;
                 results.count = 0;
                 return results;
             }

             // TODO Perf - we can loop through the filtered list if the new
             // search string starts with the old search string
             ArrayList<FilterTypeResult> filtered = new ArrayList<FilterTypeResult>();

             // ////////////////////////////////////////
             // Search by local time and GMT offset
             // ////////////////////////////////////////
             boolean gmtOnly = false;
             int startParsePosition = 0;
             if (prefixString.charAt(0) == '+' || prefixString.charAt(0) == '-') {
                 gmtOnly = true;
             }

             if (prefixString.startsWith("gmt")) {
                 startParsePosition = 3;
                 gmtOnly = true;
             }

             int num = parseNum(prefixString, startParsePosition);
             if (num != Integer.MIN_VALUE) {
                 boolean positiveOnly = prefixString.length() > startParsePosition
                         && prefixString.charAt(startParsePosition) == '+';
                 handleSearchByGmt(filtered, num, positiveOnly);
             }

             // ////////////////////////////////////////
             // Search by country
             // ////////////////////////////////////////
             ArrayList<String> countries = new ArrayList<String>();
             for (String country : mTimeZoneData.mTimeZonesByCountry.keySet()) {
                 // TODO Perf - cache toLowerCase()?
                 if (!TextUtils.isEmpty(country)) {
                     final String lowerCaseCountry = country.toLowerCase();
                     boolean isMatch = false;
                     if (lowerCaseCountry.startsWith(prefixString)
                             || (lowerCaseCountry.charAt(0) == prefixString.charAt(0) &&
                             isStartingInitialsFor(prefixString, lowerCaseCountry))) {
                         isMatch = true;
                     } else if (lowerCaseCountry.contains(" ")){
                         // We should also search other words in the country name, so that
                         // searches like "Korea" yield "South Korea".
                         for (String word : lowerCaseCountry.split(" ")) {
                             if (word.startsWith(prefixString)) {
                                 isMatch = true;
                                 break;
                             }
                         }
                     }
                     if (isMatch) {
                         countries.add(country);
                     }
                 }
             }
             if (countries.size() > 0) {
                 // Sort countries alphabetically.
                 Collections.sort(countries);
                 for (String country : countries) {
                     filtered.add(new FilterTypeResult(FILTER_TYPE_COUNTRY, country, 0));
                 }
             }

             // ////////////////////////////////////////
             // TODO Search by state
             // ////////////////////////////////////////
             if (DEBUG) {
                 Log.d(TAG, "performFiltering <<<< " + filtered.size() + "[" + prefix + "]");
             }

             results.values = filtered;
             results.count = filtered.size();
             return results;
         }

         /**
          * Returns true if the prefixString is an initial for string. Note that
          * this method will return true even if prefixString does not cover all
          * the words. Words are separated by non-letters which includes spaces
          * and symbols).
          *
          * For example:
          * isStartingInitialsFor("UA", "United Arab Emirates") would return true
          * isStartingInitialsFor("US", "U.S. Virgin Island") would return true
          *
          * @param prefixString
          * @param string
          * @return
          */
         private boolean isStartingInitialsFor(String prefixString, String string) {
             final int initialLen = prefixString.length();
             final int strLen = string.length();

             int initialIdx = 0;
             boolean wasWordBreak = true;
             for (int i = 0; i < strLen; i++) {
                 if (!Character.isLetter(string.charAt(i))) {
                     wasWordBreak = true;
                     continue;
                 }

                 if (wasWordBreak) {
                     if (prefixString.charAt(initialIdx++) != string.charAt(i)) {
                         return false;
                     }
                     if (initialIdx == initialLen) {
                         return true;
                     }
                     wasWordBreak = false;
                 }
             }

             // Special case for "USA". Note that both strings have been turned to lowercase already.
             if (prefixString.equals("usa") && string.equals("united states")) {
                 return true;
             }
             return false;
         }

         private void handleSearchByGmt(ArrayList<FilterTypeResult> filtered, int num,
                 boolean positiveOnly) {

             FilterTypeResult r;
             if (num >= 0) {
                 if (num == 1) {
                     for (int i = 19; i >= 10; i--) {
                         if (mTimeZoneData.hasTimeZonesInHrOffset(i)) {
                             r = new FilterTypeResult(FILTER_TYPE_GMT, "GMT+" + i, i);
                             filtered.add(r);
                         }
                     }
                 }

                 if (mTimeZoneData.hasTimeZonesInHrOffset(num)) {
                     r = new FilterTypeResult(FILTER_TYPE_GMT, "GMT+" + num, num);
                     filtered.add(r);
                 }
                 num *= -1;
             }

             if (!positiveOnly && num != 0) {
                 if (mTimeZoneData.hasTimeZonesInHrOffset(num)) {
                     r = new FilterTypeResult(FILTER_TYPE_GMT, "GMT" + num, num);
                     filtered.add(r);
                 }

                 if (num == -1) {
                     for (int i = -10; i >= -19; i--) {
                         if (mTimeZoneData.hasTimeZonesInHrOffset(i)) {
                             r = new FilterTypeResult(FILTER_TYPE_GMT, "GMT" + i, i);
                             filtered.add(r);
                         }
                     }
                 }
             }
         }

         /**
          * Acceptable strings are in the following format: [+-]?[0-9]?[0-9]
          *
          * @param str
          * @param startIndex
          * @return Integer.MIN_VALUE as invalid
          */
         public int parseNum(String str, int startIndex) {
             int idx = startIndex;
             int num = Integer.MIN_VALUE;
             int negativeMultiplier = 1;

             // First char - check for + and -
             char ch = str.charAt(idx++);
             switch (ch) {
                 case '-':
                     negativeMultiplier = -1;
                     // fall through
                 case '+':
                     if (idx >= str.length()) {
                         // No more digits
                         return Integer.MIN_VALUE;
                     }

                     ch = str.charAt(idx++);
                     break;
             }

             if (!Character.isDigit(ch)) {
                 // No digit
                 return Integer.MIN_VALUE;
             }

             // Got first digit
             num = Character.digit(ch, 10);

             // Check next char
             if (idx < str.length()) {
                 ch = str.charAt(idx++);
                 if (Character.isDigit(ch)) {
                     // Got second digit
                     num = 10 * num + Character.digit(ch, 10);
                 } else {
                     return Integer.MIN_VALUE;
                 }
             }

             if (idx != str.length()) {
                 // Invalid
                 return Integer.MIN_VALUE;
             }

             if (DEBUG) {
                 Log.d(TAG, "Parsing " + str + " -> " + negativeMultiplier * num);
             }
             return negativeMultiplier * num;
         }

         @SuppressWarnings("unchecked")
         @Override
         protected void publishResults(CharSequence constraint, FilterResults
                 results) {
             if (results.values == null || results.count == 0) {
                 if (mListener != null) {
                     int filterType;
                     if (TextUtils.isEmpty(constraint)) {
                         filterType = FILTER_TYPE_NONE;
                     } else {
                         filterType = FILTER_TYPE_EMPTY;
                     }
                     mListener.onSetFilter(filterType, null, 0);
                 }
                 if (DEBUG) {
                     Log.d(TAG, "publishResults: " + results.count + " of null [" + constraint);
                 }
             } else {
                 mLiveResults = (ArrayList<FilterTypeResult>) results.values;
                 if (DEBUG) {
                     Log.d(TAG, "publishResults: " + results.count + " of " + mLiveResults.size()
                             + " [" + constraint);
                 }
             }
             mLiveResultsCount = results.count;

             if (results.count > 0) {
                 notifyDataSetChanged();
             } else {
                 notifyDataSetInvalidated();
             }
         }
     }
 }
	/*
	* Copyright (C) 2013 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 com.android.timezonepicker;

	import android.content.Context;
	import android.text.TextUtils;
	import android.util.Log;
	import android.view.LayoutInflater;
	import android.view.View;
	import android.view.View.OnClickListener;
	import android.view.ViewGroup;
	import android.widget.BaseAdapter;
	import android.widget.Filter;
	import android.widget.Filterable;
	import android.widget.TextView;

	import java.util.ArrayList;
	import java.util.Collections;

	public class TimeZoneFilterTypeAdapter extends BaseAdapter implements Filterable, OnClickListener {
	public static final String TAG = "TimeZoneFilterTypeAdapter";

	private static final boolean DEBUG = false;

	public static final int FILTER_TYPE_EMPTY = -1;
	public static final int FILTER_TYPE_NONE = 0;
	public static final int FILTER_TYPE_COUNTRY = 1;
	public static final int FILTER_TYPE_STATE = 2;
	public static final int FILTER_TYPE_GMT = 3;

	public interface OnSetFilterListener {
	void onSetFilter(int filterType, String str, int time);
	}

	static class ViewHolder {
	int filterType;
	String str;
	int time;
	TextView strTextView;

	static void setupViewHolder(View v) {
	ViewHolder vh = new ViewHolder();
	vh.strTextView = (TextView) v.findViewById(R.id.value);
	v.setTag(vh);
	}
	}

	class FilterTypeResult {
	int type;
	String constraint;
	public int time;

	public FilterTypeResult(int type, String constraint, int time) {
	this.type = type;
	this.constraint = constraint;
	this.time = time;
	}

	@Override
	public String toString() {
	return constraint;
	}
	}

	private ArrayList<FilterTypeResult> mLiveResults = new ArrayList<FilterTypeResult>();
	private int mLiveResultsCount = 0;

	private ArrayFilter mFilter;

	private LayoutInflater mInflater;

	private TimeZoneData mTimeZoneData;
	private OnSetFilterListener mListener;

	public TimeZoneFilterTypeAdapter(Context context, TimeZoneData tzd, OnSetFilterListener l) {
	mTimeZoneData = tzd;
	mListener = l;
	mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
	}

	@Override
	public int getCount() {
	return mLiveResultsCount;
	}

	@Override
	public FilterTypeResult getItem(int position) {
	return mLiveResults.get(position);
	}

	@Override
	public long getItemId(int position) {
	return position;
	}

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

	if (convertView != null) {
	v = convertView;
	} else {
	v = mInflater.inflate(R.layout.time_zone_filter_item, null);
	ViewHolder.setupViewHolder(v);
	}

	ViewHolder vh = (ViewHolder) v.getTag();

	if (position >= mLiveResults.size()) {
	Log.e(TAG, "getView: " + position + " of " + mLiveResults.size());
	}

	FilterTypeResult filter = mLiveResults.get(position);

	vh.filterType = filter.type;
	vh.str = filter.constraint;
	vh.time = filter.time;
	vh.strTextView.setText(filter.constraint);
	return v;
	}

	OnClickListener mDummyListener = new OnClickListener() {

	@Override
	public void onClick(View v) {
	}
	};

	// Implements OnClickListener

	// This onClickListener is actually called from the AutoCompleteTextView's
	// onItemClickListener. Trying to update the text in AutoCompleteTextView
	// is causing an infinite loop.
	@Override
	public void onClick(View v) {
	if (mListener != null && v != null) {
	ViewHolder vh = (ViewHolder) v.getTag();
	mListener.onSetFilter(vh.filterType, vh.str, vh.time);
	}
	notifyDataSetInvalidated();
	}

	// Implements Filterable
	@Override
	public Filter getFilter() {
	if (mFilter == null) {
	mFilter = new ArrayFilter();
	}
	return mFilter;
	}

	private class ArrayFilter extends Filter {
	@Override
	protected FilterResults performFiltering(CharSequence prefix) {
	if (DEBUG) {
	Log.d(TAG, "performFiltering >>>> [" + prefix + "]");
	}

	FilterResults results = new FilterResults();
	String prefixString = null;
	if (prefix != null) {
	prefixString = prefix.toString().trim().toLowerCase();
	}

	if (TextUtils.isEmpty(prefixString)) {
	results.values = null;
	results.count = 0;
	return results;
	}

	// TODO Perf - we can loop through the filtered list if the new
	// search string starts with the old search string
	ArrayList<FilterTypeResult> filtered = new ArrayList<FilterTypeResult>();

	// ////////////////////////////////////////
	// Search by local time and GMT offset
	// ////////////////////////////////////////
	boolean gmtOnly = false;
	int startParsePosition = 0;
	if (prefixString.charAt(0) == '+' \|\| prefixString.charAt(0) == '-') {
	gmtOnly = true;
	}

	if (prefixString.startsWith("gmt")) {
	startParsePosition = 3;
	gmtOnly = true;
	}

	int num = parseNum(prefixString, startParsePosition);
	if (num != Integer.MIN_VALUE) {
	boolean positiveOnly = prefixString.length() > startParsePosition
	&& prefixString.charAt(startParsePosition) == '+';
	handleSearchByGmt(filtered, num, positiveOnly);
	}

	// ////////////////////////////////////////
	// Search by country
	// ////////////////////////////////////////
	ArrayList<String> countries = new ArrayList<String>();
	for (String country : mTimeZoneData.mTimeZonesByCountry.keySet()) {
	// TODO Perf - cache toLowerCase()?
	if (!TextUtils.isEmpty(country)) {
	final String lowerCaseCountry = country.toLowerCase();
	boolean isMatch = false;
	if (lowerCaseCountry.startsWith(prefixString)
	\|\| (lowerCaseCountry.charAt(0) == prefixString.charAt(0) &&
	isStartingInitialsFor(prefixString, lowerCaseCountry))) {
	isMatch = true;
	} else if (lowerCaseCountry.contains(" ")){
	// We should also search other words in the country name, so that
	// searches like "Korea" yield "South Korea".
	for (String word : lowerCaseCountry.split(" ")) {
	if (word.startsWith(prefixString)) {
	isMatch = true;
	break;
	}
	}
	}
	if (isMatch) {
	countries.add(country);
	}
	}
	}
	if (countries.size() > 0) {
	// Sort countries alphabetically.
	Collections.sort(countries);
	for (String country : countries) {
	filtered.add(new FilterTypeResult(FILTER_TYPE_COUNTRY, country, 0));
	}
	}

	// ////////////////////////////////////////
	// TODO Search by state
	// ////////////////////////////////////////
	if (DEBUG) {
	Log.d(TAG, "performFiltering <<<< " + filtered.size() + "[" + prefix + "]");
	}

	results.values = filtered;
	results.count = filtered.size();
	return results;
	}

	/**
	* Returns true if the prefixString is an initial for string. Note that
	* this method will return true even if prefixString does not cover all
	* the words. Words are separated by non-letters which includes spaces
	* and symbols).
	*
	* For example:
	* isStartingInitialsFor("UA", "United Arab Emirates") would return true
	* isStartingInitialsFor("US", "U.S. Virgin Island") would return true
	*
	* @param prefixString
	* @param string
	* @return
	*/
	private boolean isStartingInitialsFor(String prefixString, String string) {
	final int initialLen = prefixString.length();
	final int strLen = string.length();

	int initialIdx = 0;
	boolean wasWordBreak = true;
	for (int i = 0; i < strLen; i++) {
	if (!Character.isLetter(string.charAt(i))) {
	wasWordBreak = true;
	continue;
	}

	if (wasWordBreak) {
	if (prefixString.charAt(initialIdx++) != string.charAt(i)) {
	return false;
	}
	if (initialIdx == initialLen) {
	return true;
	}
	wasWordBreak = false;
	}
	}

	// Special case for "USA". Note that both strings have been turned to lowercase already.
	if (prefixString.equals("usa") && string.equals("united states")) {
	return true;
	}
	return false;
	}

	private void handleSearchByGmt(ArrayList<FilterTypeResult> filtered, int num,
	boolean positiveOnly) {

	FilterTypeResult r;
	if (num >= 0) {
	if (num == 1) {
	for (int i = 19; i >= 10; i--) {
	if (mTimeZoneData.hasTimeZonesInHrOffset(i)) {
	r = new FilterTypeResult(FILTER_TYPE_GMT, "GMT+" + i, i);
	filtered.add(r);
	}
	}
	}

	if (mTimeZoneData.hasTimeZonesInHrOffset(num)) {
	r = new FilterTypeResult(FILTER_TYPE_GMT, "GMT+" + num, num);
	filtered.add(r);
	}
	num *= -1;
	}

	if (!positiveOnly && num != 0) {
	if (mTimeZoneData.hasTimeZonesInHrOffset(num)) {
	r = new FilterTypeResult(FILTER_TYPE_GMT, "GMT" + num, num);
	filtered.add(r);
	}

	if (num == -1) {
	for (int i = -10; i >= -19; i--) {
	if (mTimeZoneData.hasTimeZonesInHrOffset(i)) {
	r = new FilterTypeResult(FILTER_TYPE_GMT, "GMT" + i, i);
	filtered.add(r);
	}
	}
	}
	}
	}

	/**
	* Acceptable strings are in the following format: [+-]?[0-9]?[0-9]
	*
	* @param str
	* @param startIndex
	* @return Integer.MIN_VALUE as invalid
	*/
	public int parseNum(String str, int startIndex) {
	int idx = startIndex;
	int num = Integer.MIN_VALUE;
	int negativeMultiplier = 1;

	// First char - check for + and -
	char ch = str.charAt(idx++);
	switch (ch) {
	case '-':
	negativeMultiplier = -1;
	// fall through
	case '+':
	if (idx >= str.length()) {
	// No more digits
	return Integer.MIN_VALUE;
	}

	ch = str.charAt(idx++);
	break;
	}

	if (!Character.isDigit(ch)) {
	// No digit
	return Integer.MIN_VALUE;
	}

	// Got first digit
	num = Character.digit(ch, 10);

	// Check next char
	if (idx < str.length()) {
	ch = str.charAt(idx++);
	if (Character.isDigit(ch)) {
	// Got second digit
	num = 10 * num + Character.digit(ch, 10);
	} else {
	return Integer.MIN_VALUE;
	}
	}

	if (idx != str.length()) {
	// Invalid
	return Integer.MIN_VALUE;
	}

	if (DEBUG) {
	Log.d(TAG, "Parsing " + str + " -> " + negativeMultiplier * num);
	}
	return negativeMultiplier * num;
	}

	@SuppressWarnings("unchecked")
	@Override
	protected void publishResults(CharSequence constraint, FilterResults
	results) {
	if (results.values == null \|\| results.count == 0) {
	if (mListener != null) {
	int filterType;
	if (TextUtils.isEmpty(constraint)) {
	filterType = FILTER_TYPE_NONE;
	} else {
	filterType = FILTER_TYPE_EMPTY;
	}
	mListener.onSetFilter(filterType, null, 0);
	}
	if (DEBUG) {
	Log.d(TAG, "publishResults: " + results.count + " of null [" + constraint);
	}
	} else {
	mLiveResults = (ArrayList<FilterTypeResult>) results.values;
	if (DEBUG) {
	Log.d(TAG, "publishResults: " + results.count + " of " + mLiveResults.size()
	+ " [" + constraint);
	}
	}
	mLiveResultsCount = results.count;

	if (results.count > 0) {
	notifyDataSetChanged();
	} else {
	notifyDataSetInvalidated();
	}
	}
	}
	}