mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-18 12:31:30 -10:00
300 lines
8.2 KiB
C#
300 lines
8.2 KiB
C#
/*
|
|
* System.TimeZoneInfo Android Support
|
|
*
|
|
* Author(s)
|
|
* Jonathan Pryor <[email protected]>
|
|
* 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.
|
|
*/
|
|
|
|
#if (INSIDE_CORLIB && MONODROID)
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
|
|
namespace System {
|
|
|
|
partial class TimeZoneInfo {
|
|
|
|
/*
|
|
* Android Timezone support infrastructure.
|
|
*
|
|
* This is a C# port of org.apache.harmony.luni.internal.util.ZoneInfoDB:
|
|
*
|
|
* http://android.git.kernel.org/?p=platform/libcore.git;a=blob;f=luni/src/main/java/org/apache/harmony/luni/internal/util/ZoneInfoDB.java;h=3e7bdc3a952b24da535806d434a3a27690feae26;hb=HEAD
|
|
*
|
|
* From the ZoneInfoDB source:
|
|
*
|
|
* 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.
|
|
*
|
|
* which succinctly describes why we can't just use the LIBC implementation in
|
|
* TimeZoneInfo.cs -- the "standard Unixy" directory structure is NOT used.
|
|
*/
|
|
static class ZoneInfoDB {
|
|
const int TimeZoneNameLength = 40;
|
|
const int TimeZoneIntSize = 4;
|
|
|
|
static readonly string ZoneDirectoryName = Environment.GetEnvironmentVariable ("ANDROID_ROOT") + "/usr/share/zoneinfo/";
|
|
static readonly string ZoneFileName = ZoneDirectoryName + "zoneinfo.dat";
|
|
static readonly string IndexFileName = ZoneDirectoryName + "zoneinfo.idx";
|
|
const string DefaultVersion = "2007h";
|
|
static readonly string VersionFileName = ZoneDirectoryName + "zoneinfo.version";
|
|
|
|
static readonly object _lock = new object ();
|
|
|
|
static readonly string version;
|
|
static readonly string[] names;
|
|
static readonly int[] starts;
|
|
static readonly int[] lengths;
|
|
static readonly int[] offsets;
|
|
|
|
static ZoneInfoDB ()
|
|
{
|
|
try {
|
|
version = ReadVersion ();
|
|
} catch {
|
|
version = DefaultVersion;
|
|
}
|
|
|
|
try {
|
|
ReadDatabase (out names, out starts, out lengths, out offsets);
|
|
} catch {
|
|
names = new string [0];
|
|
starts = new int [0];
|
|
lengths = new int [0];
|
|
offsets = new int [0];
|
|
}
|
|
}
|
|
|
|
static string ReadVersion ()
|
|
{
|
|
using (var file = new StreamReader (VersionFileName, Encoding.GetEncoding ("iso-8859-1"))) {
|
|
return file.ReadToEnd ().Trim ();
|
|
}
|
|
}
|
|
|
|
static void ReadDatabase (out string[] names, out int[] starts, out int[] lengths, out int[] offsets)
|
|
{
|
|
using (var file = File.OpenRead (IndexFileName)) {
|
|
var nbuf = new byte [TimeZoneNameLength];
|
|
|
|
int numEntries = (int) (file.Length / (TimeZoneNameLength + 3*TimeZoneIntSize));
|
|
|
|
char[] namebuf = new char [TimeZoneNameLength];
|
|
|
|
names = new string [numEntries];
|
|
starts = new int [numEntries];
|
|
lengths = new int [numEntries];
|
|
offsets = new int [numEntries];
|
|
|
|
for (int i = 0; i < numEntries; ++i) {
|
|
Fill (file, nbuf, nbuf.Length);
|
|
int namelen;
|
|
for (namelen = 0; namelen < nbuf.Length; ++namelen) {
|
|
if (nbuf [namelen] == '\0')
|
|
break;
|
|
namebuf [namelen] = (char) (nbuf [namelen] & 0xFF);
|
|
}
|
|
|
|
names [i] = new string (namebuf, 0, namelen);
|
|
starts [i] = ReadInt32 (file, nbuf);
|
|
lengths [i] = ReadInt32 (file, nbuf);
|
|
offsets [i] = ReadInt32 (file, nbuf);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void Fill (Stream stream, byte[] nbuf, int required)
|
|
{
|
|
int read, offset = 0;
|
|
while (offset < required && (read = stream.Read (nbuf, offset, required - offset)) > 0)
|
|
offset += read;
|
|
if (read != required)
|
|
throw new EndOfStreamException ("Needed to read " + required + " bytes; read " + read + " bytes");
|
|
}
|
|
|
|
// From java.io.RandomAccessFioe.readInt(), as we need to use the same
|
|
// byte ordering as Java uses.
|
|
static int ReadInt32 (Stream stream, byte[] nbuf)
|
|
{
|
|
Fill (stream, nbuf, 4);
|
|
return ((nbuf [0] & 0xff) << 24) + ((nbuf [1] & 0xff) << 16) +
|
|
((nbuf [2] & 0xff) << 8) + (nbuf [3] & 0xff);
|
|
}
|
|
|
|
internal static string Version {
|
|
get {return version;}
|
|
}
|
|
|
|
internal static IEnumerable<string> GetAvailableIds ()
|
|
{
|
|
return GetAvailableIds (0, false);
|
|
}
|
|
|
|
internal static IEnumerable<string> GetAvailableIds (int rawOffset)
|
|
{
|
|
return GetAvailableIds (rawOffset, true);
|
|
}
|
|
|
|
static IEnumerable<string> GetAvailableIds (int rawOffset, bool checkOffset)
|
|
{
|
|
for (int i = 0; i < offsets.Length; ++i) {
|
|
if (!checkOffset || offsets [i] == rawOffset)
|
|
yield return names [i];
|
|
}
|
|
}
|
|
|
|
static TimeZoneInfo _GetTimeZone (string name)
|
|
{
|
|
int start, length;
|
|
using (var stream = GetTimeZoneData (name, out start, out length)) {
|
|
if (stream == null)
|
|
return null;
|
|
byte[] buf = new byte [length];
|
|
Fill (stream, buf, buf.Length);
|
|
return TimeZoneInfo.ParseTZBuffer (name, buf, length);
|
|
}
|
|
}
|
|
|
|
static FileStream GetTimeZoneData (string name, out int start, out int length)
|
|
{
|
|
var f = new FileInfo (Path.Combine (ZoneDirectoryName, name));
|
|
if (f.Exists) {
|
|
start = 0;
|
|
length = (int) f.Length;
|
|
return f.OpenRead ();
|
|
}
|
|
|
|
start = length = 0;
|
|
|
|
int i = Array.BinarySearch (names, name);
|
|
if (i < 0)
|
|
return null;
|
|
|
|
start = starts [i];
|
|
length = lengths [i];
|
|
|
|
var stream = File.OpenRead (ZoneFileName);
|
|
stream.Seek (start, SeekOrigin.Begin);
|
|
|
|
return stream;
|
|
}
|
|
|
|
internal static TimeZoneInfo GetTimeZone (string id)
|
|
{
|
|
if (id != null) {
|
|
if (id == "GMT" || id == "UTC")
|
|
return new TimeZoneInfo (id, TimeSpan.FromSeconds (0), id, id, id, null, true);
|
|
if (id.StartsWith ("GMT"))
|
|
return new TimeZoneInfo (id,
|
|
TimeSpan.FromSeconds (ParseNumericZone (id)),
|
|
id, id, id, null, true);
|
|
}
|
|
|
|
try {
|
|
return _GetTimeZone (id);
|
|
} catch (Exception e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
static int ParseNumericZone (string name)
|
|
{
|
|
if (name == null || !name.StartsWith ("GMT") || name.Length <= 3)
|
|
return 0;
|
|
|
|
int sign;
|
|
if (name [3] == '+')
|
|
sign = 1;
|
|
else if (name [3] == '-')
|
|
sign = -1;
|
|
else
|
|
return 0;
|
|
|
|
int where;
|
|
int hour = 0;
|
|
bool colon = false;
|
|
for (where = 4; where < name.Length; where++) {
|
|
char c = name [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 [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;
|
|
}
|
|
|
|
static TimeZoneInfo defaultZone;
|
|
internal static TimeZoneInfo Default {
|
|
get {
|
|
lock (_lock) {
|
|
if (defaultZone != null)
|
|
return defaultZone;
|
|
return defaultZone = GetTimeZone (GetDefaultTimeZoneName ());
|
|
}
|
|
}
|
|
}
|
|
|
|
// <sys/system_properties.h>
|
|
[DllImport ("/system/lib/libc.so")]
|
|
static extern int __system_property_get (string name, StringBuilder value);
|
|
|
|
const int MaxPropertyNameLength = 32; // <sys/system_properties.h>
|
|
const int MaxPropertyValueLength = 92; // <sys/system_properties.h>
|
|
|
|
static string GetDefaultTimeZoneName ()
|
|
{
|
|
var buf = new StringBuilder (MaxPropertyValueLength + 1);
|
|
int n = __system_property_get ("persist.sys.timezone", buf);
|
|
if (n > 0)
|
|
return buf.ToString ();
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif // MONODROID
|
|
|