/*
* Copyright (C) 2007 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 org.apache.harmony.luni.internal.util;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.TimeZone;
import java.util.logging.Logger;
/**
* A class used to initialize the time zone database. This implementation uses the
* 'zoneinfo' database as the source of time zone information. However, to conserve
* disk space the data for all time zones are concatenated into a single file, and a
* second file is used to indicate the starting position of each time zone record. A
* third file indicates the version of the zoneinfo databse used to generate the data.
*
* {@hide}
*/
public final class ZoneInfoDB {
private static final int TZNAME_LENGTH = 40;
private static final int TZINT_LENGTH = 4;
/**
* The directory contining the time zone database files.
*/
private static final String ZONE_DIRECTORY_NAME =
System.getenv("ANDROID_ROOT") + "/usr/share/zoneinfo/";
/**
* The name of the file containing the concatenated time zone records.
*/
private static final String ZONE_FILE_NAME =
ZONE_DIRECTORY_NAME + "zoneinfo.dat";
/**
* The name of the file containing the index to each time zone record within
* the zoneinfo.dat file.
*/
private static final String INDEX_FILE_NAME =
ZONE_DIRECTORY_NAME + "zoneinfo.idx";
/**
* Zoneinfo version used prior to creation of the zoneinfo.version file,
* equal to "2007h".
*/
private static final String DEFAULT_VERSION = "2007h";
/**
* The name of the file indicating the database version in use. If the file is not
* present or is unreadable, we assume a version of DEFAULT_VERSION.
*/
private static final String VERSION_FILE_NAME =
ZONE_DIRECTORY_NAME + "zoneinfo.version";
private static Object lock = new Object();
private static TimeZone defaultZone = null;
private static String version;
private static String[] names;
private static int[] starts;
private static int[] lengths;
private static int[] offsets;
/**
* This class is uninstantiable.
*/
private ZoneInfoDB() {
// This space intentionally left blank.
}
private static void readVersion() throws IOException {
RandomAccessFile versionFile = new RandomAccessFile(VERSION_FILE_NAME, "r");
int len = (int) versionFile.length();
byte[] vbuf = new byte[len];
versionFile.readFully(vbuf);
version = new String(vbuf, 0, len, "ISO-8859-1").trim();
versionFile.close();
}
private static void readDatabase() throws IOException {
if (starts != null) {
return;
}
RandomAccessFile indexFile = new RandomAccessFile(INDEX_FILE_NAME, "r");
byte[] nbuf = new byte[TZNAME_LENGTH];
int numEntries =
(int) (indexFile.length() / (TZNAME_LENGTH + 3*TZINT_LENGTH));
char[] namebuf = new char[numEntries * TZNAME_LENGTH];
int[] nameend = new int[numEntries];
int nameoff = 0;
starts = new int[numEntries];
lengths = new int[numEntries];
offsets = new int[numEntries];
for (int i = 0; i < numEntries; i++) {
indexFile.readFully(nbuf);
starts[i] = indexFile.readInt();
lengths[i] = indexFile.readInt();
offsets[i] = indexFile.readInt();
// Don't include null chars in the String
int len = nbuf.length;
for (int j = 0; j < len; j++) {
if (nbuf[j] == 0) {
break;
}
namebuf[nameoff++] = (char) (nbuf[j] & 0xFF);
}
nameend[i] = nameoff;
}
String name = new String(namebuf, 0, nameoff);
// Assumes the namebuf is all ASCII (so byte offsets == char offsets).
names = new String[numEntries];
for (int i = 0; i < numEntries; i++) {
names[i] = name.substring(i == 0 ? 0 : nameend[i - 1],
nameend[i]);
}
indexFile.close();
}
static {
// Don't attempt to log here because the logger requires this class to be initialized
try {
readVersion();
} catch (IOException e) {
// The version can't be read, we can continue without it
version = DEFAULT_VERSION;
}
try {
readDatabase();
} catch (IOException e) {
// The database can't be read, try to continue without it
names = new String[0];
starts = new int[0];
lengths = new int[0];
offsets = new int[0];
}
}
public static String getVersion() {
return version;
}
public static String[] getAvailableIDs() {
return _getAvailableIDs(0, false);
}
public static String[] getAvailableIDs(int rawOffset) {
return _getAvailableIDs(rawOffset, true);
}
private static String[] _getAvailableIDs(int rawOffset,
boolean checkOffset) {
List<String> matches = new ArrayList<String>();
int[] _offsets = ZoneInfoDB.offsets;
String[] _names = ZoneInfoDB.names;
int len = _offsets.length;
for (int i = 0; i < len; i++) {
if (!checkOffset || _offsets[i] == rawOffset) {
matches.add(_names[i]);
}
}
return matches.toArray(new String[matches.size()]);
}
/*package*/ static TimeZone _getTimeZone(String name)
throws IOException {
FileInputStream fis = null;
int length = 0;
File f = new File(ZONE_DIRECTORY_NAME + name);
if (!f.exists()) {
fis = new FileInputStream(ZONE_FILE_NAME);
int i = Arrays.binarySearch(ZoneInfoDB.names, name);
if (i < 0) {
return null;
}
int start = ZoneInfoDB.starts[i];
length = ZoneInfoDB.lengths[i];
fis.skip(start);
}
if (fis == null) {
fis = new FileInputStream(f);
length = (int)f.length(); // data won't exceed 2G!
}
byte[] data = new byte[length];
int nread = 0;
while (nread < length) {
int size = fis.read(data, nread, length - nread);
if (size > 0) {
nread += size;
}
}
try {
fis.close();
} catch (IOException e3) {
// probably better to continue than to fail here
java.util.logging.Logger.global.warning("IOException " + e3 +
" retrieving time zone data");
e3.printStackTrace();
}
if (data.length < 36) {
return null;
}
if (data[0] != 'T' || data[1] != 'Z' ||
data[2] != 'i' || data[3] != 'f') {
return null;
}
int ntransition = read4(data, 32);
int ngmtoff = read4(data, 36);
int base = 44;
int[] transitions = new int[ntransition];
for (int i = 0; i < ntransition; i++)
transitions[i] = read4(data, base + 4 * i);
base += 4 * ntransition;
byte[] type = new byte[ntransition];
for (int i = 0; i < ntransition; i++)
type[i] = data[base + i];
base += ntransition;
int[] gmtoff = new int[ngmtoff];
byte[] isdst = new byte[ngmtoff];
byte[] abbrev = new byte[ngmtoff];
for (int i = 0; i < ngmtoff; i++) {
gmtoff[i] = read4(data, base + 6 * i);
isdst[i] = data[base + 6 * i + 4];
abbrev[i] = data[base + 6 * i + 5];
}
base += 6 * ngmtoff;
return new ZoneInfo(name, transitions, type, gmtoff, isdst, abbrev, data, base);
}
private static int read4(byte[] data, int off) {
return ((data[off ] & 0xFF) << 24) |
((data[off + 1] & 0xFF) << 16) |
((data[off + 2] & 0xFF) << 8) |
((data[off + 3] & 0xFF) << 0);
}
public static TimeZone getTimeZone(String id) {
if (id != null) {
if (id.equals("GMT") || id.equals("UTC")) {
TimeZone tz = new MinimalTimeZone(0);
tz.setID(id);
return tz;
}
if (id.startsWith("GMT")) {
return new MinimalTimeZone(parseNumericZone(id) * 1000);
}
}
TimeZone tz = ZoneInfo.getTimeZone(id);
if (tz != null)
return tz;
/*
* It isn't GMT+anything, and it also isn't something we have
* in the database. Give up and return GMT.
*/
tz = new MinimalTimeZone(0);
tz.setID("GMT");
return tz;
}
public static TimeZone getDefault() {
TimeZone zone;
synchronized (lock) {
if (defaultZone != null) {
return defaultZone;
}
String zoneName = null;
TimezoneGetter tzGetter = TimezoneGetter.getInstance();
if (tzGetter != null) {
zoneName = tzGetter.getId();
}
if (zoneName != null && zoneName.length() > 0) {
zone = TimeZone.getTimeZone(zoneName.trim());
} else {
// use localtime here so that the simulator works
zone = TimeZone.getTimeZone("localtime");
}
defaultZone = zone;
}
return zone;
}
// TODO - why does this ignore the 'zone' parameter?
public static void setDefault(@SuppressWarnings("unused") TimeZone zone) {
/*
* if (zone == null), the next call to getDefault will set it to the
* the system's default time zone.
*/
synchronized (lock) {
defaultZone = null;
}
}
private static int parseNumericZone(String name) {
if (name == null)
return 0;
if (!name.startsWith("GMT"))
return 0;
if (name.length() == 3)
return 0;
int sign;
if (name.charAt(3) == '+')
sign = 1;
else if (name.charAt(3) == '-')
sign = -1;
else
return 0;
int where;
int hour = 0;
boolean colon = false;
for (where = 4; where < name.length(); where++) {
char c = name.charAt(where);
if (c == ':') {
where++;
colon = true;
break;
}
if (c >= '0' && c <= '9')
hour = hour * 10 + c - '0';
else
return 0;
}
int min = 0;
for (; where < name.length(); where++) {
char c = name.charAt(where);
if (c >= '0' && c <= '9')
min = min * 10 + c - '0';
else
return 0;
}
if (colon)
return sign * (hour * 60 + min) * 60;
else if (hour >= 100)
return sign * ((hour / 100) * 60 + (hour % 100)) * 60;
else
return sign * (hour * 60) * 60;
}
/*package*/ static class MinimalTimeZone extends TimeZone {
private int rawOffset;
public MinimalTimeZone(int offset) {
rawOffset = offset;
setID(getDisplayName());
}
@SuppressWarnings("unused")
@Override
public int getOffset(int era, int year, int month, int day, int dayOfWeek, int millis) {
return getRawOffset();
}
@Override
public int getRawOffset() {
return rawOffset;
}
@Override
public void setRawOffset(int off) {
rawOffset = off;
}
@SuppressWarnings("unused")
@Override
public boolean inDaylightTime(Date when) {
return false;
}
@Override
public boolean useDaylightTime() {
return false;
}
}
}
|
