04487594d7
This fixes ar, fa, and he/iw. Bug: 10231161 Change-Id: I31acc044443c026ba8b8e1967810f7aa476bcae7
347 lines
13 KiB
Java
347 lines
13 KiB
Java
/*
|
|
* Copyright (C) 2006 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.settings;
|
|
|
|
import android.app.Activity;
|
|
import android.app.AlarmManager;
|
|
import android.app.ListFragment;
|
|
import android.content.Context;
|
|
import android.content.res.XmlResourceParser;
|
|
import android.os.Bundle;
|
|
import android.util.Log;
|
|
import android.view.LayoutInflater;
|
|
import android.view.Menu;
|
|
import android.view.MenuInflater;
|
|
import android.view.MenuItem;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.widget.ListView;
|
|
import android.widget.SimpleAdapter;
|
|
|
|
import org.xmlpull.v1.XmlPullParserException;
|
|
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.ArrayList;
|
|
import java.util.Calendar;
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.TimeZone;
|
|
import libcore.icu.ICU;
|
|
import libcore.icu.TimeZoneNames;
|
|
|
|
/**
|
|
* The class displaying a list of time zones that match a filter string
|
|
* such as "Africa", "Europe", etc. Choosing an item from the list will set
|
|
* the time zone. Pressing Back without choosing from the list will not
|
|
* result in a change in the time zone setting.
|
|
*/
|
|
public class ZonePicker extends ListFragment {
|
|
private static final String TAG = "ZonePicker";
|
|
|
|
public static interface ZoneSelectionListener {
|
|
// You can add any argument if you really need it...
|
|
public void onZoneSelected(TimeZone tz);
|
|
}
|
|
|
|
private static final String KEY_ID = "id"; // value: String
|
|
private static final String KEY_DISPLAYNAME = "name"; // value: String
|
|
private static final String KEY_GMT = "gmt"; // value: String
|
|
private static final String KEY_OFFSET = "offset"; // value: int (Integer)
|
|
private static final String XMLTAG_TIMEZONE = "timezone";
|
|
|
|
private static final int HOURS_1 = 60 * 60000;
|
|
|
|
private static final int MENU_TIMEZONE = Menu.FIRST+1;
|
|
private static final int MENU_ALPHABETICAL = Menu.FIRST;
|
|
|
|
private boolean mSortedByTimezone;
|
|
|
|
private SimpleAdapter mTimezoneSortedAdapter;
|
|
private SimpleAdapter mAlphabeticalAdapter;
|
|
|
|
private ZoneSelectionListener mListener;
|
|
|
|
/**
|
|
* Constructs an adapter with TimeZone list. Sorted by TimeZone in default.
|
|
*
|
|
* @param sortedByName use Name for sorting the list.
|
|
*/
|
|
public static SimpleAdapter constructTimezoneAdapter(Context context,
|
|
boolean sortedByName) {
|
|
return constructTimezoneAdapter(context, sortedByName,
|
|
R.layout.date_time_setup_custom_list_item_2);
|
|
}
|
|
|
|
/**
|
|
* Constructs an adapter with TimeZone list. Sorted by TimeZone in default.
|
|
*
|
|
* @param sortedByName use Name for sorting the list.
|
|
*/
|
|
public static SimpleAdapter constructTimezoneAdapter(Context context,
|
|
boolean sortedByName, int layoutId) {
|
|
final String[] from = new String[] {KEY_DISPLAYNAME, KEY_GMT};
|
|
final int[] to = new int[] {android.R.id.text1, android.R.id.text2};
|
|
|
|
final String sortKey = (sortedByName ? KEY_DISPLAYNAME : KEY_OFFSET);
|
|
final MyComparator comparator = new MyComparator(sortKey);
|
|
ZoneGetter zoneGetter = new ZoneGetter();
|
|
final List<HashMap<String, Object>> sortedList = zoneGetter.getZones(context);
|
|
Collections.sort(sortedList, comparator);
|
|
final SimpleAdapter adapter = new SimpleAdapter(context,
|
|
sortedList,
|
|
layoutId,
|
|
from,
|
|
to);
|
|
|
|
return adapter;
|
|
}
|
|
|
|
/**
|
|
* Searches {@link TimeZone} from the given {@link SimpleAdapter} object, and returns
|
|
* the index for the TimeZone.
|
|
*
|
|
* @param adapter SimpleAdapter constructed by
|
|
* {@link #constructTimezoneAdapter(Context, boolean)}.
|
|
* @param tz TimeZone to be searched.
|
|
* @return Index for the given TimeZone. -1 when there's no corresponding list item.
|
|
* returned.
|
|
*/
|
|
public static int getTimeZoneIndex(SimpleAdapter adapter, TimeZone tz) {
|
|
final String defaultId = tz.getID();
|
|
final int listSize = adapter.getCount();
|
|
for (int i = 0; i < listSize; i++) {
|
|
// Using HashMap<String, Object> induces unnecessary warning.
|
|
final HashMap<?,?> map = (HashMap<?,?>)adapter.getItem(i);
|
|
final String id = (String)map.get(KEY_ID);
|
|
if (defaultId.equals(id)) {
|
|
// If current timezone is in this list, move focus to it
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* @param item one of items in adapters. The adapter should be constructed by
|
|
* {@link #constructTimezoneAdapter(Context, boolean)}.
|
|
* @return TimeZone object corresponding to the item.
|
|
*/
|
|
public static TimeZone obtainTimeZoneFromItem(Object item) {
|
|
return TimeZone.getTimeZone((String)((Map<?, ?>)item).get(KEY_ID));
|
|
}
|
|
|
|
@Override
|
|
public void onActivityCreated(Bundle savedInstanceState) {
|
|
super.onActivityCreated(savedInstanceState);
|
|
|
|
final Activity activity = getActivity();
|
|
mTimezoneSortedAdapter = constructTimezoneAdapter(activity, false);
|
|
mAlphabeticalAdapter = constructTimezoneAdapter(activity, true);
|
|
|
|
// Sets the adapter
|
|
setSorting(true);
|
|
setHasOptionsMenu(true);
|
|
}
|
|
|
|
@Override
|
|
public View onCreateView(LayoutInflater inflater, ViewGroup container,
|
|
Bundle savedInstanceState) {
|
|
final View view = super.onCreateView(inflater, container, savedInstanceState);
|
|
final ListView list = (ListView) view.findViewById(android.R.id.list);
|
|
Utils.forcePrepareCustomPreferencesList(container, view, list, false);
|
|
return view;
|
|
}
|
|
|
|
@Override
|
|
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
|
|
menu.add(0, MENU_ALPHABETICAL, 0, R.string.zone_list_menu_sort_alphabetically)
|
|
.setIcon(android.R.drawable.ic_menu_sort_alphabetically);
|
|
menu.add(0, MENU_TIMEZONE, 0, R.string.zone_list_menu_sort_by_timezone)
|
|
.setIcon(R.drawable.ic_menu_3d_globe);
|
|
super.onCreateOptionsMenu(menu, inflater);
|
|
}
|
|
|
|
@Override
|
|
public void onPrepareOptionsMenu(Menu menu) {
|
|
if (mSortedByTimezone) {
|
|
menu.findItem(MENU_TIMEZONE).setVisible(false);
|
|
menu.findItem(MENU_ALPHABETICAL).setVisible(true);
|
|
} else {
|
|
menu.findItem(MENU_TIMEZONE).setVisible(true);
|
|
menu.findItem(MENU_ALPHABETICAL).setVisible(false);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean onOptionsItemSelected(MenuItem item) {
|
|
switch (item.getItemId()) {
|
|
|
|
case MENU_TIMEZONE:
|
|
setSorting(true);
|
|
return true;
|
|
|
|
case MENU_ALPHABETICAL:
|
|
setSorting(false);
|
|
return true;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public void setZoneSelectionListener(ZoneSelectionListener listener) {
|
|
mListener = listener;
|
|
}
|
|
|
|
private void setSorting(boolean sortByTimezone) {
|
|
final SimpleAdapter adapter =
|
|
sortByTimezone ? mTimezoneSortedAdapter : mAlphabeticalAdapter;
|
|
setListAdapter(adapter);
|
|
mSortedByTimezone = sortByTimezone;
|
|
final int defaultIndex = getTimeZoneIndex(adapter, TimeZone.getDefault());
|
|
if (defaultIndex >= 0) {
|
|
setSelection(defaultIndex);
|
|
}
|
|
}
|
|
|
|
static class ZoneGetter {
|
|
private final List<HashMap<String, Object>> mZones =
|
|
new ArrayList<HashMap<String, Object>>();
|
|
private final HashSet<String> mLocalZones = new HashSet<String>();
|
|
private final Date mNow = Calendar.getInstance().getTime();
|
|
private final SimpleDateFormat mZoneNameFormatter = new SimpleDateFormat("zzzz");
|
|
|
|
private List<HashMap<String, Object>> getZones(Context context) {
|
|
for (String olsonId : TimeZoneNames.forLocale(Locale.getDefault())) {
|
|
mLocalZones.add(olsonId);
|
|
}
|
|
try {
|
|
XmlResourceParser xrp = context.getResources().getXml(R.xml.timezones);
|
|
while (xrp.next() != XmlResourceParser.START_TAG) {
|
|
continue;
|
|
}
|
|
xrp.next();
|
|
while (xrp.getEventType() != XmlResourceParser.END_TAG) {
|
|
while (xrp.getEventType() != XmlResourceParser.START_TAG) {
|
|
if (xrp.getEventType() == XmlResourceParser.END_DOCUMENT) {
|
|
return mZones;
|
|
}
|
|
xrp.next();
|
|
}
|
|
if (xrp.getName().equals(XMLTAG_TIMEZONE)) {
|
|
String olsonId = xrp.getAttributeValue(0);
|
|
addTimeZone(olsonId);
|
|
}
|
|
while (xrp.getEventType() != XmlResourceParser.END_TAG) {
|
|
xrp.next();
|
|
}
|
|
xrp.next();
|
|
}
|
|
xrp.close();
|
|
} catch (XmlPullParserException xppe) {
|
|
Log.e(TAG, "Ill-formatted timezones.xml file");
|
|
} catch (java.io.IOException ioe) {
|
|
Log.e(TAG, "Unable to read timezones.xml file");
|
|
}
|
|
return mZones;
|
|
}
|
|
|
|
private void addTimeZone(String olsonId) {
|
|
// We always need the "GMT-07:00" string.
|
|
final TimeZone tz = TimeZone.getTimeZone(olsonId);
|
|
|
|
// For the display name, we treat time zones within the country differently
|
|
// from other countries' time zones. So in en_US you'd get "Pacific Daylight Time"
|
|
// but in de_DE you'd get "Los Angeles" for the same time zone.
|
|
String displayName;
|
|
if (mLocalZones.contains(olsonId)) {
|
|
// Within a country, we just use the local name for the time zone.
|
|
mZoneNameFormatter.setTimeZone(tz);
|
|
displayName = mZoneNameFormatter.format(mNow);
|
|
} else {
|
|
// For other countries' time zones, we use the exemplar location.
|
|
final String localeName = Locale.getDefault().toString();
|
|
displayName = TimeZoneNames.getExemplarLocation(localeName, olsonId);
|
|
}
|
|
|
|
final HashMap<String, Object> map = new HashMap<String, Object>();
|
|
map.put(KEY_ID, olsonId);
|
|
map.put(KEY_DISPLAYNAME, displayName);
|
|
map.put(KEY_GMT, DateTimeSettings.getTimeZoneText(tz, false));
|
|
map.put(KEY_OFFSET, tz.getOffset(mNow.getTime()));
|
|
|
|
mZones.add(map);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onListItemClick(ListView listView, View v, int position, long id) {
|
|
final Map<?, ?> map = (Map<?, ?>)listView.getItemAtPosition(position);
|
|
final String tzId = (String) map.get(KEY_ID);
|
|
|
|
// Update the system timezone value
|
|
final Activity activity = getActivity();
|
|
final AlarmManager alarm = (AlarmManager) activity.getSystemService(Context.ALARM_SERVICE);
|
|
alarm.setTimeZone(tzId);
|
|
final TimeZone tz = TimeZone.getTimeZone(tzId);
|
|
if (mListener != null) {
|
|
mListener.onZoneSelected(tz);
|
|
} else {
|
|
getActivity().onBackPressed();
|
|
}
|
|
}
|
|
|
|
private static class MyComparator implements Comparator<HashMap<?, ?>> {
|
|
private String mSortingKey;
|
|
|
|
public MyComparator(String sortingKey) {
|
|
mSortingKey = sortingKey;
|
|
}
|
|
|
|
public void setSortingKey(String sortingKey) {
|
|
mSortingKey = sortingKey;
|
|
}
|
|
|
|
public int compare(HashMap<?, ?> map1, HashMap<?, ?> map2) {
|
|
Object value1 = map1.get(mSortingKey);
|
|
Object value2 = map2.get(mSortingKey);
|
|
|
|
/*
|
|
* This should never happen, but just in-case, put non-comparable
|
|
* items at the end.
|
|
*/
|
|
if (!isComparable(value1)) {
|
|
return isComparable(value2) ? 1 : 0;
|
|
} else if (!isComparable(value2)) {
|
|
return -1;
|
|
}
|
|
|
|
return ((Comparable) value1).compareTo(value2);
|
|
}
|
|
|
|
private boolean isComparable(Object value) {
|
|
return (value != null) && (value instanceof Comparable);
|
|
}
|
|
}
|
|
}
|