[android] Support for time zones in Android.

The time zone database in Android sits in a non-standard place, and it
can be overridedn by a second location. Besides not sitting in a standard
place, it differs from other Unixes in that the database is bundled into
one binary file, and there are no folders with small files for each time
zone. Luckily the database is generated from Olson, so most of the
CFTimeZone code already handles the details.

The code implements a generic enumeration of the time zones contained in
the database (checking for both the override and the standard location).
The enumeration code is used for both enumerating the known time zones,
as well as creating time zones by name.

At many points there was code blocking the usage of time zones in
Android that has been removed.

This allows the tests in TestDateFormatter, TestCalendar and
TestTimeZone to pass on Android.

Author: drodriguez

CoreFoundation/NumberDate.subproj/CFTimeZone.c

@@ -30,6 +30,8 @@
 #include <unistd.h>
 #if !TARGET_OS_ANDROID
 #include <sys/fcntl.h>
+#else
+#include <sys/endian.h>
 #endif
 #endif
 #if TARGET_OS_WIN32
@@ -70,7 +72,7 @@ struct tzhead {
 
 #include <time.h>
 
-#if !TARGET_OS_WIN32
+#if !TARGET_OS_WIN32 && !TARGET_OS_ANDROID
 static CFStringRef __tzZoneInfo = NULL;
 static char *__tzDir = NULL;
 static void __InitTZStrings(void);
@@ -183,11 +185,133 @@ static void __CFTimeZoneGetOffset(CFStringRef timezone, int32_t *offset) {
 
     RegCloseKey(hKey);
 }
+#elif TARGET_OS_ANDROID
+typedef Boolean (*__CFAndroidTimeZoneListEnumerateCallback)(const char name[40], int32_t start, int32_t length, FILE *fp, void *context);
+
+static void __CFAndroidTimeZoneListEnumerate(__CFAndroidTimeZoneListEnumerateCallback callback, void *context) {
+    // The best reference should be Android Bionic's libc/tzcode/bionic.cpp
+    static const char *tzDataFiles[] = {
+        "/data/misc/zoneinfo/current/tzdata",
+        "/system/usr/share/zoneinfo/tzdata"
+    };
+
+    Boolean done = FALSE;
+    for (int idx = 0; idx < sizeof(tzDataFiles)/sizeof(tzDataFiles[0]) && !done; idx++) {
+        FILE *fp = fopen(tzDataFiles[idx], "rb");
+        if (!fp) {
+            continue;
+        }
+
+        char header[24];
+        if (fread(header, 1, sizeof(header), fp) != sizeof(header)) {
+            fclose(fp);
+            continue;
+        }
+        if (strncmp(header, "tzdata", 6) != 0) {
+            fclose(fp);
+            continue;
+        }
+
+        int32_t indexOffset;
+        memcpy(&indexOffset, &header[12], sizeof(int32_t));
+        indexOffset = betoh32(indexOffset);
+
+        int32_t dataOffset;
+        memcpy(&dataOffset, &header[16], sizeof(int32_t));
+        dataOffset = betoh32(dataOffset);
+
+        if (indexOffset < 0 || dataOffset < indexOffset) {
+            fclose(fp);
+            continue;
+        }
+        if (fseek(fp, indexOffset, SEEK_SET) != 0) {
+            fclose(fp);
+            continue;
+        }
+
+        char entry[52];
+        size_t indexSize = dataOffset - indexOffset;
+        size_t zoneCount = indexSize / sizeof(entry);
+        if (zoneCount * sizeof(entry) != indexSize) {
+            fclose(fp);
+            continue;
+        }
+        for (size_t idx = 0; idx < zoneCount; idx++) {
+            if (fread(entry, 1, sizeof(entry), fp) != sizeof(entry)) {
+                break;
+            }
+            int32_t start;
+            memcpy(&start, &entry[40], sizeof(int32_t));
+            start = betoh32(start);
+            start += dataOffset;
+            int32_t length;
+            memcpy(&length, &entry[44], sizeof(int32_t));
+            length = betoh32(length);
+            if (start < 0 || length < 0) {
+                break;
+            }
+
+            done = callback(entry, start, length, fp, context);
+            if (done) {
+                break;
+            }
+        }
+
+        fclose(fp);
+    }
+}
+
+static Boolean __CFCopyAndroidTimeZoneListCallback(const char name[40], int32_t start, int32_t length, FILE *fp, void *context) {
+    CFMutableArrayRef result = (CFMutableArrayRef)context;
+    CFStringRef timeZoneName = CFStringCreateWithCString(kCFAllocatorSystemDefault, name, kCFStringEncodingASCII);
+    CFArrayAppendValue(result, timeZoneName);
+    CFRelease(timeZoneName);
+    return FALSE;
+}
+
+struct __CFTimeZoneDataCreateContext {
+    const char *tzNameCstr;
+    CFDataRef *dataPtr;
+};
+
+static Boolean __CFTimeZoneDataCreateCallback(const char name[40], int32_t start, int32_t length, FILE *fp, void *context) {
+    struct __CFTimeZoneDataCreateContext *ctx = (struct __CFTimeZoneDataCreateContext *)context;
+    char *tzNameCstr = ctx->tzNameCstr;
+    CFDataRef *dataPtr = ctx->dataPtr;
+
+    if (strncmp(tzNameCstr, name, 40) == 0) {
+        if (fseek(fp, start, SEEK_SET) != 0) {
+            return TRUE;
+        }
+        uint8_t *bytes = malloc(length);
+        if (!bytes) {
+            return TRUE;
+        }
+        if (fread(bytes, 1, length, fp) != length) {
+            free(bytes);
+            return TRUE;
+        }
+        *dataPtr = CFDataCreate(kCFAllocatorSystemDefault, bytes, length);
+        free(bytes);
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+static CFMutableArrayRef __CFCopyAndroidTimeZoneList() {
+    CFMutableArrayRef result = CFArrayCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeArrayCallBacks);
+    __CFAndroidTimeZoneListEnumerate(__CFCopyAndroidTimeZoneListCallback, result);
+    return result;
+}
+
 #elif TARGET_OS_MAC || TARGET_OS_LINUX || TARGET_OS_BSD
 static CFMutableArrayRef __CFCopyRecursiveDirectoryList() {
     CFMutableArrayRef result = CFArrayCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeArrayCallBacks);
+#if !TARGET_OS_ANDROID
     if (!__tzDir) __InitTZStrings();
     if (!__tzDir) return result;
+#endif
     int fd = open(__tzDir, O_RDONLY);
 
     for (; 0 <= fd;) {
@@ -637,7 +761,7 @@ static void __InitTZStrings(void) {
     });
 }
 
-#elif TARGET_OS_LINUX || TARGET_OS_BSD
+#elif TARGET_OS_LINUX || TARGET_OS_BSD && !TARGET_OS_ANDROID
 static void __InitTZStrings(void) {
     __tzZoneInfo = CFSTR(TZDIR);
     __tzDir = TZDIR "zone.tab";
@@ -690,7 +814,9 @@ static CFTimeZoneRef __CFTimeZoneCreateSystem(void) {
         if (result) return result;
     }
 
+#if !TARGET_OS_ANDROID
     if (!__tzZoneInfo) __InitTZStrings();
+#endif
     ret = readlink(TZDEFAULT, linkbuf, sizeof(linkbuf));
     if (__tzZoneInfo && (0 < ret)) {
         linkbuf[ret] = '\0';
@@ -718,15 +844,6 @@ static CFTimeZoneRef __CFTimeZoneCreateSystem(void) {
         CFRelease(name);
         if (result) return result;
     }
-#if TARGET_OS_ANDROID
-    // Timezone database by name not available on Android.
-    // Approximate with gmtoff - could be general default.
-    struct tm info;
-    time_t now = time(NULL);
-    if (NULL != localtime_r(&now, &info)) {
-        return CFTimeZoneCreateWithTimeIntervalFromGMT(kCFAllocatorSystemDefault, info.tm_gmtoff);
-    }
-#endif
     return CFTimeZoneCreateWithTimeIntervalFromGMT(kCFAllocatorSystemDefault, 0.0);
 }
 
@@ -808,6 +925,8 @@ CFArrayRef CFTimeZoneCopyKnownNames(void) {
  */
 #if TARGET_OS_WIN32
         list = __CFCopyWindowsTimeZoneList();
+#elif TARGET_OS_ANDROID
+        list = __CFCopyAndroidTimeZoneList();
 #else
         list = __CFCopyRecursiveDirectoryList();
 #endif
@@ -1059,6 +1178,37 @@ Boolean _CFTimeZoneInitInternal(CFTimeZoneRef timezone, CFStringRef name, CFData
 }
 
 CFDataRef _CFTimeZoneDataCreate(CFURLRef baseURL, CFStringRef tzName) {
+#if TARGET_OS_ANDROID
+    CFDataRef data = NULL;
+    char *buffer = NULL;
+    const char *tzNameCstr = CFStringGetCStringPtr(tzName, kCFStringEncodingASCII);
+    if (!tzNameCstr) {
+        CFIndex maxSize = CFStringGetMaximumSizeForEncoding(CFStringGetLength(tzName), kCFStringEncodingASCII) + 2;
+        if (maxSize == kCFNotFound) {
+            return NULL;
+        }
+        buffer = malloc(maxSize);
+        if (!buffer) {
+            return NULL;
+        }
+        if (CFStringGetCString(tzName, buffer, maxSize, kCFStringEncodingASCII)) {
+            tzNameCstr = buffer;
+        }
+    }
+    if (!tzNameCstr) {
+        free(buffer);
+        return NULL;
+    }
+
+    struct __CFTimeZoneDataCreateContext context = {
+        .tzNameCstr = tzNameCstr,
+        .dataPtr = &data,
+    };
+    __CFAndroidTimeZoneListEnumerate(__CFTimeZoneDataCreateCallback, &context);
+
+    free(buffer);
+    return data;
+#else
     void *bytes;
     CFIndex length;
     CFDataRef data = NULL;
@@ -1070,6 +1220,7 @@ CFDataRef _CFTimeZoneDataCreate(CFURLRef baseURL, CFStringRef tzName) {
         CFRelease(tempURL);
     }
     return data;
+#endif
 }
 
 Boolean _CFTimeZoneInit(CFTimeZoneRef timeZone, CFStringRef name, CFDataRef data) {
@@ -1133,8 +1284,10 @@ Boolean _CFTimeZoneInit(CFTimeZoneRef timeZone, CFStringRef name, CFDataRef data
 
     return FALSE;
 #else
+#if !TARGET_OS_ANDROID
     if (!__tzZoneInfo) __InitTZStrings();
     if (!__tzZoneInfo) return NULL;
+#endif
     baseURL = CFURLCreateWithFileSystemPath(kCFAllocatorSystemDefault, __tzZoneInfo, kCFURLPOSIXPathStyle, true);
 
     CFDictionaryRef abbrevs = CFTimeZoneCopyAbbreviationDictionary();
@@ -1337,8 +1490,10 @@ CFTimeZoneRef CFTimeZoneCreateWithName(CFAllocatorRef allocator, CFStringRef nam
 
     return result;
 #else
+#if !TARGET_OS_ANDROID
     if (!__tzZoneInfo) __InitTZStrings();
     if (!__tzZoneInfo) return NULL;
+#endif
     baseURL = CFURLCreateWithFileSystemPath(kCFAllocatorSystemDefault, __tzZoneInfo, kCFURLPOSIXPathStyle, true);
     if (tryAbbrev) {
 	CFDictionaryRef abbrevs = CFTimeZoneCopyAbbreviationDictionary();

Foundation/NSTimeZone.swift

@@ -29,17 +29,13 @@ open class NSTimeZone : NSObject, NSCopying, NSSecureCoding, NSCoding {
     }
 
     public init?(name tzName: String, data aData: Data?) {
-#if os(Android) || os(Windows)
+#if os(Windows)
         var tzName = tzName
         if tzName == "UTC" || tzName == "GMT" {
             tzName = "GMT+0000"
         }
         else if !(tzName.hasPrefix("GMT+") || tzName.hasPrefix("GMT-")) {
-#if os(Android)
-            NSLog("Time zone database not available on Android")
-#else
             NSLog("Time zone database not available on Windows")
-#endif
         }
 #endif
 

TestFoundation/TestCodable.swift

@@ -345,7 +345,6 @@ class TestCodable : XCTestCase {
 
     // MARK: - TimeZone
     lazy var timeZoneValues: [TimeZone] = {
-#if !os(Android)
         var values = [
             TimeZone(identifier: "America/Los_Angeles")!,
             TimeZone(identifier: "UTC")!,
@@ -355,12 +354,6 @@ class TestCodable : XCTestCase {
         // TimeZone.current == TimeZone(identifier: TimeZone.current.identifier) equality,
         // causing encode -> decode -> compare test to fail.
         // values.append(TimeZone.current)
-#else
-        var values = [
-            TimeZone(identifier: "UTC")!,
-            TimeZone.current
-            ]
-#endif
         return values
     }()
 

TestFoundation/TestISO8601DateFormatter.swift

@@ -111,7 +111,6 @@ class TestISO8601DateFormatter: XCTestCase {
         isoFormatter.formatOptions = [.withMonth, .withDay, .withWeekOfYear, .withDashSeparatorInDate]
         XCTAssertEqual(isoFormatter.string(from: someDateTime), "10-W40-06")
 
-#if !os(Android)
         /*
          The following tests cover various cases when changing the .formatOptions property with a different TimeZone set.
          */
@@ -153,7 +152,6 @@ class TestISO8601DateFormatter: XCTestCase {
 
         isoFormatter.formatOptions = [.withDay, .withWeekOfYear, .withMonth, .withTimeZone, .withColonSeparatorInTimeZone, .withDashSeparatorInDate]
         XCTAssertEqual(isoFormatter.string(from: someDateTime), "10-W40-06-07:00")
-#endif
     }
 
 
@@ -270,7 +268,6 @@ class TestISO8601DateFormatter: XCTestCase {
         formatOptions = [.withMonth, .withDay, .withWeekOfYear, .withDashSeparatorInDate]
         XCTAssertEqual(ISO8601DateFormatter.string(from: someDateTime, timeZone: timeZone, formatOptions: formatOptions), "10-W40-06")
 
-#if !os(Android)
         /*
          The following tests cover various cases when changing the .formatOptions property with a different TimeZone set.
          */
@@ -315,7 +312,6 @@ class TestISO8601DateFormatter: XCTestCase {
 
         formatOptions = [.withDay, .withWeekOfYear, .withMonth, .withTimeZone, .withColonSeparatorInTimeZone, .withDashSeparatorInDate]
         XCTAssertEqual(ISO8601DateFormatter.string(from: someDateTime, timeZone: pstTimeZone, formatOptions: formatOptions), "10-W40-06-07:00")
-#endif
     }
 
 }

TestFoundation/TestTimeZone.swift

@@ -102,9 +102,6 @@ class TestTimeZone: XCTestCase {
     }
 
     func test_localizedName() {
-#if os(Android)
-	XCTFail("Named timezones not available on Android")
-#else
         let initialTimeZone = NSTimeZone.default
         NSTimeZone.default = TimeZone(identifier: "America/New_York")!
         let defaultTimeZone = NSTimeZone.default
@@ -116,7 +113,6 @@ class TestTimeZone: XCTestCase {
         XCTAssertEqual(defaultTimeZone.localizedName(for: .shortDaylightSaving, locale: locale), "EDT")
         XCTAssertEqual(defaultTimeZone.localizedName(for: .shortGeneric, locale: locale), "ET")
         NSTimeZone.default = initialTimeZone //reset the TimeZone
-#endif
     }
 
     func test_initializingTimeZoneWithOffset() {