[android] Support for time zones in Android.

The time zone database in Android sits in a non-standard place, and it
can be overriden 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.

To simplify the code a little, a duplicated piece of code in
_CFTimeZoneInit has been extracted into _CFTimeZoneDataCreate. While the
code is quite simple for Unix, the Android code is a little bit more
complicated, and I prefer not to repeat the same and having two blocks
of platform conditional code. This change should be the only change that
might modify the behaviour of CoreFoundation on Darwin or Linux.

At many points there were 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
@@ -183,6 +185,121 @@ static void __CFTimeZoneGetOffset(CFStringRef timezone, int32_t *offset) {
 
     RegCloseKey(hKey);
 }
+#elif TARGET_OS_ANDROID
+typedef Boolean (*__CFAndroidTimeZoneListEnumerateCallback)(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(char name[40], int32_t start, int32_t length, FILE *fp, void *context) {
+    CFMutableArrayRef result = (CFMutableArrayRef)context;
+    size_t lenght = strnlen(name, 40);
+    CFStringRef timeZoneName = CFStringCreateWithCString(kCFAllocatorSystemDefault, name, kCFStringEncodingASCII);
+    CFArrayAppendValue(result, timeZoneName);
+    CFRelease(timeZoneName);
+    return FALSE;
+}
+
+struct __CFTimeZoneDataCreateContext {
+    const char *tzNameCstr;
+    CFDataRef *dataPtr;
+};
+
+static Boolean __CFTimeZoneDataCreateCallback(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) {
+            return TRUE;
+        }
+        *dataPtr = CFDataCreate(kCFAllocatorSystemDefault, bytes, length);
+        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);
@@ -637,6 +754,13 @@ static void __InitTZStrings(void) {
     });
 }
 
+#elif TARGET_OS_ANDROID
+static void __InitTZStrings(void) {
+    // NOTE: Android doesn't use this values. Only as markers.
+    __tzZoneInfo = CFSTR("/system/usr/share/timezone/");
+    __tzDir = "/system/usr/share/timezone/tzdata";
+}
+
 #elif TARGET_OS_LINUX || TARGET_OS_BSD
 static void __InitTZStrings(void) {
     __tzZoneInfo = CFSTR(TZDIR);
@@ -718,15 +842,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 +923,8 @@ CFArrayRef CFTimeZoneCopyKnownNames(void) {
  */
 #if TARGET_OS_WIN32
         list = __CFCopyWindowsTimeZoneList();
+#elif TARGET_OS_ANDROID
+        list = __CFCopyAndroidTimeZoneList();
 #else
         list = __CFCopyRecursiveDirectoryList();
 #endif
@@ -1058,6 +1175,53 @@ Boolean _CFTimeZoneInitInternal(CFTimeZoneRef timezone, CFStringRef name, CFData
     return success;
 }
 
+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) {
+        return NULL;
+    }
+
+    struct __CFTimeZoneDataCreateContext context = {
+        .tzNameCstr = tzNameCstr,
+        .dataPtr = &data,
+    };
+    __CFAndroidTimeZoneListEnumerate(__CFTimeZoneDataCreateCallback, &context);
+
+    if (buffer) {
+        free(buffer);
+    }
+    return data;
+#else
+    void *bytes;
+    CFIndex length;
+    CFDataRef data = NULL;
+    CFURLRef tempURL = CFURLCreateCopyAppendingPathComponent(kCFAllocatorSystemDefault, baseURL, tzName, false);
+    if (NULL != tempURL) {
+        if (_CFReadBytesFromFile(kCFAllocatorSystemDefault, tempURL, &bytes, &length, 0, 0)) {
+            data = CFDataCreateWithBytesNoCopy(kCFAllocatorSystemDefault, bytes, length, kCFAllocatorSystemDefault);
+        }
+        CFRelease(tempURL);
+    }
+    return data;
+#endif
+}
+
 Boolean _CFTimeZoneInit(CFTimeZoneRef timeZone, CFStringRef name, CFDataRef data) {
     if (!name || !__nameStringOK(name)) {
         return false;
@@ -1093,9 +1257,7 @@ Boolean _CFTimeZoneInit(CFTimeZoneRef timeZone, CFStringRef name, CFDataRef data
     }
 
     CFStringRef tzName = NULL;
-    CFURLRef baseURL, tempURL;
-    void *bytes;
-    CFIndex length;
+    CFURLRef baseURL;
     Boolean result = false;
 
 #if TARGET_OS_WIN32
@@ -1128,13 +1290,7 @@ Boolean _CFTimeZoneInit(CFTimeZoneRef timeZone, CFStringRef name, CFDataRef data
     CFDictionaryRef abbrevs = CFTimeZoneCopyAbbreviationDictionary();
     tzName = CFDictionaryGetValue(abbrevs, name);
     if (NULL != tzName) {
-        tempURL = CFURLCreateCopyAppendingPathComponent(kCFAllocatorSystemDefault, baseURL, tzName, false);
-        if (NULL != tempURL) {
-            if (_CFReadBytesFromFile(kCFAllocatorSystemDefault, tempURL, &bytes, &length, 0, 0)) {
-                data = CFDataCreateWithBytesNoCopy(kCFAllocatorSystemDefault, bytes, length, kCFAllocatorSystemDefault);
-            }
-            CFRelease(tempURL);
-        }
+        data = _CFTimeZoneDataCreate(baseURL, tzName);
     }
     CFRelease(abbrevs);
 
@@ -1159,13 +1315,7 @@ Boolean _CFTimeZoneInit(CFTimeZoneRef timeZone, CFStringRef name, CFDataRef data
     }
     if (NULL == data) {
         tzName = name;
-        tempURL = CFURLCreateCopyAppendingPathComponent(kCFAllocatorSystemDefault, baseURL, tzName, false);
-        if (NULL != tempURL) {
-            if (_CFReadBytesFromFile(kCFAllocatorSystemDefault, tempURL, &bytes, &length, 0, 0)) {
-                data = CFDataCreateWithBytesNoCopy(kCFAllocatorSystemDefault, bytes, length, kCFAllocatorSystemDefault);
-            }
-            CFRelease(tempURL);
-        }
+        data = _CFTimeZoneDataCreate(baseURL, tzName);
     }
     CFRelease(baseURL);
     if (NULL != data) {

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/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() {