Home | History | Annotate | Download | only in native 
      1 /*
      2  * Copyright (C) 2008 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #define LOG_TAG "ICU"
     18 
     19 #include "JNIHelp.h"
     20 #include "JniConstants.h"
     21 #include "JniException.h"
     22 #include "ScopedFd.h"
     23 #include "ScopedJavaUnicodeString.h"
     24 #include "ScopedLocalRef.h"
     25 #include "ScopedStringChars.h"
     26 #include "ScopedUtfChars.h"
     27 #include "UniquePtr.h"
     28 #include "cutils/log.h"
     29 #include "toStringArray.h"
     30 #include "unicode/calendar.h"
     31 #include "unicode/datefmt.h"
     32 #include "unicode/dcfmtsym.h"
     33 #include "unicode/decimfmt.h"
     34 #include "unicode/dtfmtsym.h"
     35 #include "unicode/gregocal.h"
     36 #include "unicode/locid.h"
     37 #include "unicode/numfmt.h"
     38 #include "unicode/strenum.h"
     39 #include "unicode/ubrk.h"
     40 #include "unicode/ucal.h"
     41 #include "unicode/uclean.h"
     42 #include "unicode/ucol.h"
     43 #include "unicode/ucurr.h"
     44 #include "unicode/udat.h"
     45 #include "unicode/uloc.h"
     46 #include "unicode/ustring.h"
     47 #include "ureslocs.h"
     48 #include "valueOf.h"
     49 
     50 #include <errno.h>
     51 #include <fcntl.h>
     52 #include <stdlib.h>
     53 #include <string.h>
     54 #include <string>
     55 #include <sys/mman.h>
     56 #include <sys/stat.h>
     57 #include <sys/time.h>
     58 #include <sys/types.h>
     59 #include <time.h>
     60 #include <unistd.h>
     61 
     62 class ScopedResourceBundle {
     63 public:
     64     ScopedResourceBundle(UResourceBundle* bundle) : mBundle(bundle) {
     65     }
     66 
     67     ~ScopedResourceBundle() {
     68         if (mBundle != NULL) {
     69             ures_close(mBundle);
     70         }
     71     }
     72 
     73     UResourceBundle* get() {
     74         return mBundle;
     75     }
     76 
     77 private:
     78     UResourceBundle* mBundle;
     79 
     80     // Disallow copy and assignment.
     81     ScopedResourceBundle(const ScopedResourceBundle&);
     82     void operator=(const ScopedResourceBundle&);
     83 };
     84 
     85 Locale getLocale(JNIEnv* env, jstring localeName) {
     86     return Locale::createFromName(ScopedUtfChars(env, localeName).c_str());
     87 }
     88 
     89 static jstring ICU_addLikelySubtags(JNIEnv* env, jclass, jstring javaLocale) {
     90     UErrorCode status = U_ZERO_ERROR;
     91     ScopedUtfChars localeID(env, javaLocale);
     92     char maximizedLocaleID[ULOC_FULLNAME_CAPACITY];
     93     uloc_addLikelySubtags(localeID.c_str(), maximizedLocaleID, sizeof(maximizedLocaleID), &status);
     94     if (U_FAILURE(status)) {
     95         return javaLocale;
     96     }
     97     return env->NewStringUTF(maximizedLocaleID);
     98 }
     99 
    100 static jstring ICU_getScript(JNIEnv* env, jclass, jstring javaLocale) {
    101     UErrorCode status = U_ZERO_ERROR;
    102     ScopedUtfChars localeID(env, javaLocale);
    103     char script[ULOC_SCRIPT_CAPACITY];
    104     uloc_getScript(localeID.c_str(), script, sizeof(script), &status);
    105     if (U_FAILURE(status)) {
    106         return NULL;
    107     }
    108     return env->NewStringUTF(script);
    109 }
    110 
    111 static jint ICU_getCurrencyFractionDigits(JNIEnv* env, jclass, jstring javaCurrencyCode) {
    112     ScopedJavaUnicodeString currencyCode(env, javaCurrencyCode);
    113     UnicodeString icuCurrencyCode(currencyCode.unicodeString());
    114     UErrorCode status = U_ZERO_ERROR;
    115     return ucurr_getDefaultFractionDigits(icuCurrencyCode.getTerminatedBuffer(), &status);
    116 }
    117 
    118 static jstring ICU_getCurrencyCode(JNIEnv* env, jclass, jstring javaCountryCode) {
    119     UErrorCode status = U_ZERO_ERROR;
    120     ScopedResourceBundle supplData(ures_openDirect(U_ICUDATA_CURR, "supplementalData", &status));
    121     if (U_FAILURE(status)) {
    122         return NULL;
    123     }
    124 
    125     ScopedResourceBundle currencyMap(ures_getByKey(supplData.get(), "CurrencyMap", NULL, &status));
    126     if (U_FAILURE(status)) {
    127         return NULL;
    128     }
    129 
    130     ScopedUtfChars countryCode(env, javaCountryCode);
    131     ScopedResourceBundle currency(ures_getByKey(currencyMap.get(), countryCode.c_str(), NULL, &status));
    132     if (U_FAILURE(status)) {
    133         return NULL;
    134     }
    135 
    136     ScopedResourceBundle currencyElem(ures_getByIndex(currency.get(), 0, NULL, &status));
    137     if (U_FAILURE(status)) {
    138         return env->NewStringUTF("None");
    139     }
    140 
    141     // Check if there's a 'to' date. If there is, the currency isn't used anymore.
    142     ScopedResourceBundle currencyTo(ures_getByKey(currencyElem.get(), "to", NULL, &status));
    143     if (!U_FAILURE(status)) {
    144         return NULL;
    145     }
    146     // Ignore the failure to find a 'to' date.
    147     status = U_ZERO_ERROR;
    148 
    149     ScopedResourceBundle currencyId(ures_getByKey(currencyElem.get(), "id", NULL, &status));
    150     if (U_FAILURE(status)) {
    151         // No id defined for this country
    152         return env->NewStringUTF("None");
    153     }
    154 
    155     int32_t charCount;
    156     const jchar* chars = ures_getString(currencyId.get(), &charCount, &status);
    157     return (charCount == 0) ? env->NewStringUTF("None") : env->NewString(chars, charCount);
    158 }
    159 
    160 static jstring ICU_getCurrencyDisplayName(JNIEnv* env, jclass, jstring javaLocaleName, jstring javaCurrencyCode) {
    161     ScopedUtfChars localeName(env, javaLocaleName);
    162     ScopedJavaUnicodeString currencyCode(env, javaCurrencyCode);
    163     UnicodeString icuCurrencyCode(currencyCode.unicodeString());
    164     UErrorCode status = U_ZERO_ERROR;
    165     UBool isChoiceFormat;
    166     int32_t charCount;
    167     const UChar* chars = ucurr_getName(icuCurrencyCode.getTerminatedBuffer(), localeName.c_str(),
    168             UCURR_LONG_NAME, &isChoiceFormat, &charCount, &status);
    169     if (status == U_USING_DEFAULT_WARNING) {
    170         // ICU's default is English. We want the ISO 4217 currency code instead.
    171         chars = icuCurrencyCode.getBuffer();
    172         charCount = icuCurrencyCode.length();
    173     }
    174     return (charCount == 0) ? NULL : env->NewString(chars, charCount);
    175 }
    176 
    177 static jstring ICU_getCurrencySymbol(JNIEnv* env, jclass, jstring locale, jstring currencyCode) {
    178     // We can't use ucurr_getName because it doesn't distinguish between using data root from
    179     // the root locale and parroting back the input because it's never heard of the currency code.
    180     ScopedUtfChars localeName(env, locale);
    181     UErrorCode status = U_ZERO_ERROR;
    182     ScopedResourceBundle currLoc(ures_open(U_ICUDATA_CURR, localeName.c_str(), &status));
    183     if (U_FAILURE(status)) {
    184         return NULL;
    185     }
    186 
    187     ScopedResourceBundle currencies(ures_getByKey(currLoc.get(), "Currencies", NULL, &status));
    188     if (U_FAILURE(status)) {
    189         return NULL;
    190     }
    191 
    192     ScopedUtfChars currency(env, currencyCode);
    193     ScopedResourceBundle currencyElems(ures_getByKey(currencies.get(), currency.c_str(), NULL, &status));
    194     if (U_FAILURE(status)) {
    195         return NULL;
    196     }
    197 
    198     int32_t charCount;
    199     const jchar* chars = ures_getStringByIndex(currencyElems.get(), 0, &charCount, &status);
    200     if (U_FAILURE(status)) {
    201         return NULL;
    202     }
    203     return (charCount == 0) ? NULL : env->NewString(chars, charCount);
    204 }
    205 
    206 static jstring ICU_getDisplayCountryNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
    207     Locale loc = getLocale(env, locale);
    208     Locale targetLoc = getLocale(env, targetLocale);
    209     UnicodeString str;
    210     targetLoc.getDisplayCountry(loc, str);
    211     return env->NewString(str.getBuffer(), str.length());
    212 }
    213 
    214 static jstring ICU_getDisplayLanguageNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
    215     Locale loc = getLocale(env, locale);
    216     Locale targetLoc = getLocale(env, targetLocale);
    217     UnicodeString str;
    218     targetLoc.getDisplayLanguage(loc, str);
    219     return env->NewString(str.getBuffer(), str.length());
    220 }
    221 
    222 static jstring ICU_getDisplayVariantNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
    223     Locale loc = getLocale(env, locale);
    224     Locale targetLoc = getLocale(env, targetLocale);
    225     UnicodeString str;
    226     targetLoc.getDisplayVariant(loc, str);
    227     return env->NewString(str.getBuffer(), str.length());
    228 }
    229 
    230 static jstring ICU_getISO3CountryNative(JNIEnv* env, jclass, jstring locale) {
    231     Locale loc = getLocale(env, locale);
    232     return env->NewStringUTF(loc.getISO3Country());
    233 }
    234 
    235 static jstring ICU_getISO3LanguageNative(JNIEnv* env, jclass, jstring locale) {
    236     Locale loc = getLocale(env, locale);
    237     return env->NewStringUTF(loc.getISO3Language());
    238 }
    239 
    240 static jobjectArray ICU_getISOCountriesNative(JNIEnv* env, jclass) {
    241     return toStringArray(env, Locale::getISOCountries());
    242 }
    243 
    244 static jobjectArray ICU_getISOLanguagesNative(JNIEnv* env, jclass) {
    245     return toStringArray(env, Locale::getISOLanguages());
    246 }
    247 
    248 static jobjectArray ICU_getAvailableLocalesNative(JNIEnv* env, jclass) {
    249     return toStringArray(env, uloc_countAvailable, uloc_getAvailable);
    250 }
    251 
    252 static jobjectArray ICU_getAvailableBreakIteratorLocalesNative(JNIEnv* env, jclass) {
    253     return toStringArray(env, ubrk_countAvailable, ubrk_getAvailable);
    254 }
    255 
    256 static jobjectArray ICU_getAvailableCalendarLocalesNative(JNIEnv* env, jclass) {
    257     return toStringArray(env, ucal_countAvailable, ucal_getAvailable);
    258 }
    259 
    260 static jobjectArray ICU_getAvailableCollatorLocalesNative(JNIEnv* env, jclass) {
    261     return toStringArray(env, ucol_countAvailable, ucol_getAvailable);
    262 }
    263 
    264 static jobjectArray ICU_getAvailableDateFormatLocalesNative(JNIEnv* env, jclass) {
    265     return toStringArray(env, udat_countAvailable, udat_getAvailable);
    266 }
    267 
    268 static jobjectArray ICU_getAvailableNumberFormatLocalesNative(JNIEnv* env, jclass) {
    269     return toStringArray(env, unum_countAvailable, unum_getAvailable);
    270 }
    271 
    272 static bool getDayIntVector(JNIEnv*, UResourceBundle* gregorian, int* values) {
    273     // get the First day of week and the minimal days in first week numbers
    274     UErrorCode status = U_ZERO_ERROR;
    275     ScopedResourceBundle gregorianElems(ures_getByKey(gregorian, "DateTimeElements", NULL, &status));
    276     if (U_FAILURE(status)) {
    277         return false;
    278     }
    279 
    280     int intVectSize;
    281     const int* result = ures_getIntVector(gregorianElems.get(), &intVectSize, &status);
    282     if (U_FAILURE(status) || intVectSize != 2) {
    283         return false;
    284     }
    285 
    286     values[0] = result[0];
    287     values[1] = result[1];
    288     return true;
    289 }
    290 
    291 // This allows you to leave extra space at the beginning or end of the array to support the
    292 // month names and day names arrays.
    293 static jobjectArray toStringArray(JNIEnv* env, UResourceBundle* rb, size_t size, int capacity, size_t offset) {
    294     if (capacity == -1) {
    295         capacity = size;
    296     }
    297     jobjectArray result = env->NewObjectArray(capacity, JniConstants::stringClass, NULL);
    298     if (result == NULL) {
    299         return NULL;
    300     }
    301     UErrorCode status = U_ZERO_ERROR;
    302     for (size_t i = 0; i < size; ++i) {
    303         int charCount;
    304         const jchar* chars = ures_getStringByIndex(rb, i, &charCount, &status);
    305         if (U_FAILURE(status)) {
    306             return NULL;
    307         }
    308         ScopedLocalRef<jstring> s(env, env->NewString(chars, charCount));
    309         if (env->ExceptionCheck()) {
    310             return NULL;
    311         }
    312         env->SetObjectArrayElement(result, offset + i, s.get());
    313         if (env->ExceptionCheck()) {
    314             return NULL;
    315         }
    316     }
    317     return result;
    318 }
    319 
    320 static jobjectArray getAmPmMarkers(JNIEnv* env, UResourceBundle* gregorian) {
    321     UErrorCode status = U_ZERO_ERROR;
    322     ScopedResourceBundle amPmMarkers(ures_getByKey(gregorian, "AmPmMarkers", NULL, &status));
    323     if (U_FAILURE(status)) {
    324         return NULL;
    325     }
    326     return toStringArray(env, amPmMarkers.get(), ures_getSize(amPmMarkers.get()), -1, 0);
    327 }
    328 
    329 static jobjectArray getEras(JNIEnv* env, UResourceBundle* gregorian) {
    330     UErrorCode status = U_ZERO_ERROR;
    331     ScopedResourceBundle eras(ures_getByKey(gregorian, "eras", NULL, &status));
    332     if (U_FAILURE(status)) {
    333         return NULL;
    334     }
    335     ScopedResourceBundle abbreviatedEras(ures_getByKey(eras.get(), "abbreviated", NULL, &status));
    336     if (U_FAILURE(status)) {
    337         return NULL;
    338     }
    339     return toStringArray(env, abbreviatedEras.get(), ures_getSize(abbreviatedEras.get()), -1, 0);
    340 }
    341 
    342 enum NameType { REGULAR, STAND_ALONE };
    343 enum NameWidth { LONG, SHORT };
    344 static jobjectArray getNames(JNIEnv* env, UResourceBundle* namesBundle, bool months, NameType type, NameWidth width) {
    345     const char* typeKey = (type == REGULAR) ? "format" : "stand-alone";
    346     const char* widthKey = (width == LONG) ? "wide" : "abbreviated";
    347     UErrorCode status = U_ZERO_ERROR;
    348     ScopedResourceBundle formatBundle(ures_getByKey(namesBundle, typeKey, NULL, &status));
    349     ScopedResourceBundle valuesBundle(ures_getByKey(formatBundle.get(), widthKey, NULL, &status));
    350     if (U_FAILURE(status)) {
    351         return NULL;
    352     }
    353 
    354     // The months array has a trailing empty string. The days array has a leading empty string.
    355     int count = ures_getSize(valuesBundle.get());
    356     int offset = months ? 0 : 1;
    357     jobjectArray result = toStringArray(env, valuesBundle.get(), count, count + 1, offset);
    358     ScopedLocalRef<jstring> emptyString(env, env->NewStringUTF(""));
    359     env->SetObjectArrayElement(result, months ? count : 0, emptyString.get());
    360     return result;
    361 }
    362 
    363 static void setIntegerField(JNIEnv* env, jobject obj, const char* fieldName, int value) {
    364     ScopedLocalRef<jobject> integerValue(env, integerValueOf(env, value));
    365     jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "Ljava/lang/Integer;");
    366     env->SetObjectField(obj, fid, integerValue.get());
    367 }
    368 
    369 static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, jstring value) {
    370     jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "Ljava/lang/String;");
    371     env->SetObjectField(obj, fid, value);
    372     env->DeleteLocalRef(value);
    373 }
    374 
    375 static void setStringArrayField(JNIEnv* env, jobject obj, const char* fieldName, jobjectArray value) {
    376     jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "[Ljava/lang/String;");
    377     env->SetObjectField(obj, fid, value);
    378 }
    379 
    380 static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, UResourceBundle* bundle, int index) {
    381     UErrorCode status = U_ZERO_ERROR;
    382     int charCount;
    383     const UChar* chars = ures_getStringByIndex(bundle, index, &charCount, &status);
    384     if (U_SUCCESS(status)) {
    385         setStringField(env, obj, fieldName, env->NewString(chars, charCount));
    386     } else {
    387         LOGE("Error setting String field %s from ICU resource: %s", fieldName, u_errorName(status));
    388     }
    389 }
    390 
    391 static bool setStringField(JNIEnv* env, jobject obj, const char* key, const char* fieldName, UResourceBundle* bundle) {
    392     if (bundle == NULL) {
    393         return false;
    394     }
    395     UErrorCode status = U_ZERO_ERROR;
    396     int charCount;
    397     const UChar* chars = ures_getStringByKey(bundle, key, &charCount, &status);
    398     if (U_SUCCESS(status)) {
    399         setStringField(env, obj, fieldName, env->NewString(chars, charCount));
    400         return true;
    401     } else {
    402         // Missing item in current resource bundle but not an error.
    403         return false;
    404     }
    405 }
    406 
    407 static void setStringField(JNIEnv* env, jobject obj, const char* key, const char* fieldName,
    408     UResourceBundle* bundle, UResourceBundle* fallbackBundle) {
    409     if (!setStringField(env, obj, key, fieldName, bundle) && fallbackBundle != NULL) {
    410         setStringField(env, obj, key, fieldName, fallbackBundle);
    411     }
    412 }
    413 
    414 static bool setCharField(JNIEnv* env, jobject obj, const char* key, const char* fieldName,
    415     UResourceBundle* bundle) {
    416     if (bundle == NULL) {
    417         return false;
    418     }
    419     UErrorCode status = U_ZERO_ERROR;
    420     int charCount;
    421     const UChar* chars = ures_getStringByKey(bundle, key, &charCount, &status);
    422     if (U_SUCCESS(status)) {
    423         jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "C");
    424         env->SetCharField(obj, fid, chars[0]);
    425         return true;
    426     } else {
    427         // Missing item in current resource bundle but not an error.
    428         return false;
    429     }
    430 }
    431 
    432 static void setCharField(JNIEnv* env, jobject obj, const char* key, const char* fieldName,
    433     UResourceBundle* bundle, UResourceBundle* fallbackBundle) {
    434     if (!setCharField(env, obj, key, fieldName, bundle) && fallbackBundle != NULL) {
    435         setCharField(env, obj, key, fieldName, fallbackBundle);
    436     }
    437 }
    438 
    439 static void setNumberSymbols(JNIEnv* env, jobject obj, UResourceBundle* numberSymbols, UResourceBundle* fallbackNumberSymbols) {
    440     setCharField(env, obj, "decimal", "decimalSeparator", numberSymbols, fallbackNumberSymbols);
    441     setCharField(env, obj, "group", "groupingSeparator", numberSymbols, fallbackNumberSymbols);
    442     setCharField(env, obj, "list", "patternSeparator", numberSymbols, fallbackNumberSymbols);
    443     setCharField(env, obj, "percentSign", "percent", numberSymbols, fallbackNumberSymbols);
    444     setCharField(env, obj, "perMille", "perMill", numberSymbols, fallbackNumberSymbols);
    445     setCharField(env, obj, "decimal", "monetarySeparator", numberSymbols, fallbackNumberSymbols);
    446     setCharField(env, obj, "minusSign", "minusSign", numberSymbols, fallbackNumberSymbols);
    447     setStringField(env, obj, "exponential", "exponentSeparator", numberSymbols, fallbackNumberSymbols);
    448     setStringField(env, obj, "infinity", "infinity", numberSymbols, fallbackNumberSymbols);
    449     setStringField(env, obj, "nan", "NaN", numberSymbols, fallbackNumberSymbols);
    450 }
    451 
    452 static void setZeroDigitToDefault(JNIEnv* env, jobject obj) {
    453     static jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, "zeroDigit", "C");
    454     env->SetCharField(obj, fid, '0');
    455 }
    456 
    457 static void setZeroDigit(JNIEnv* env, jobject obj, bool isLatn, char* buffer) {
    458     if (isLatn || buffer == NULL || buffer[0] == '\0') {
    459         return setZeroDigitToDefault(env, obj);
    460     }
    461     UErrorCode status = U_ZERO_ERROR;
    462     ScopedResourceBundle numSystemRoot(ures_openDirect(NULL, "numberingSystems", &status));
    463     if (U_FAILURE(status)) {
    464         return setZeroDigitToDefault(env, obj);
    465     }
    466     ScopedResourceBundle numSystem(ures_getByKey(numSystemRoot.get(), "numberingSystems", NULL, &status));
    467     if (U_FAILURE(status)) {
    468         return setZeroDigitToDefault(env, obj);
    469     }
    470     ScopedResourceBundle nonLatnSystem(ures_getByKey(numSystem.get(), buffer, NULL, &status));
    471     if (U_FAILURE(status)) {
    472         return setZeroDigitToDefault(env, obj);
    473     }
    474     int32_t charCount = 0;
    475     const UChar* chars = ures_getStringByKey(nonLatnSystem.get(), "desc", &charCount, &status);
    476     if (charCount == 0) {
    477         setZeroDigitToDefault(env, obj);
    478     } else {
    479         static jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, "zeroDigit", "C");
    480         env->SetCharField(obj, fid, chars[0]);
    481     }
    482 }
    483 
    484 static void setNumberElements(JNIEnv* env, jobject obj, UResourceBundle* numberElements) {
    485     UErrorCode status = U_ZERO_ERROR;
    486     ScopedResourceBundle latnNumberRB(ures_getByKey(numberElements, "latn", NULL, &status));
    487     if (U_FAILURE(status)) {
    488         LOGW("Error getting ICU latn number elements system value: %s", u_errorName(status));
    489         return;
    490     }
    491     ScopedResourceBundle patternsRB(ures_getByKey(latnNumberRB.get(), "patterns", NULL, &status));
    492     if (U_FAILURE(status)) {
    493         LOGW("Error getting ICU latn number patterns value: %s", u_errorName(status));
    494         return;
    495     }
    496     // Get the patterns from the 'latn' numberElements
    497     // This is a temporary workaround for ICU ticket#8611.
    498     UResourceBundle* bundle = patternsRB.get();
    499     setStringField(env, obj, "currencyFormat", "currencyPattern", bundle);
    500     setStringField(env, obj, "decimalFormat", "numberPattern", bundle);
    501     setStringField(env, obj, "percentFormat", "percentPattern", bundle);
    502 
    503     status = U_ZERO_ERROR;
    504     bool isLatn = false;
    505     char buffer[256];
    506     buffer[0] = '\0';
    507     ScopedResourceBundle defaultNumberElem(ures_getByKey(numberElements, "default", NULL, &status));
    508     if (U_SUCCESS(status)) {
    509         int32_t charCount = 256;
    510         ures_getUTF8String(defaultNumberElem.get(), buffer, &charCount, true, &status);
    511         buffer[charCount] = '\0';
    512         if (U_FAILURE(status)) {
    513             LOGW("Error getting ICU default number element system value: %s", u_errorName(status));
    514             // Use latn number symbols instead.
    515             isLatn = true;
    516         } else {
    517             isLatn = (strcmp(buffer, "latn") == 0);
    518         }
    519     } else {
    520         // Not default data, fallback to latn number elements.
    521         isLatn = true;
    522     }
    523 
    524     status = U_ZERO_ERROR;
    525     setZeroDigit(env, obj, isLatn, buffer);
    526     if (isLatn) {
    527         ScopedResourceBundle symbolsRB(ures_getByKey(latnNumberRB.get(), "symbols", NULL, &status));
    528         if (U_SUCCESS(status)) {
    529             setNumberSymbols(env, obj, symbolsRB.get(), NULL);
    530         } else {
    531             LOGW("Missing ICU latn symbols system value: %s", u_errorName(status));
    532         }
    533     } else {
    534         // Get every symbol item from default numbering system first. If it does not
    535         // exist, get the symbol from latn numbering system.
    536         ScopedResourceBundle defaultNumberRB(ures_getByKey(numberElements, (const char*)buffer, NULL, &status));
    537         ScopedResourceBundle defaultSymbolsRB(ures_getByKey(defaultNumberRB.get(), "symbols", NULL, &status));
    538         if (U_FAILURE(status)) {
    539             LOGW("Missing ICU %s symbols system value: %s", buffer, u_errorName(status));
    540             isLatn = true;  // Fallback to latn symbols.
    541             status = U_ZERO_ERROR;
    542         }
    543         ScopedResourceBundle latnSymbolsRB(ures_getByKey(latnNumberRB.get(), "symbols", NULL, &status));
    544         if (isLatn && U_FAILURE(status)) {
    545             return;
    546         }
    547         setNumberSymbols(env, obj, defaultSymbolsRB.get(), latnSymbolsRB.get());
    548     }
    549 }
    550 
    551 static jboolean ICU_initLocaleDataImpl(JNIEnv* env, jclass, jstring locale, jobject localeData) {
    552     ScopedUtfChars localeName(env, locale);
    553     if (localeName.c_str() == NULL) {
    554         return JNI_FALSE;
    555     }
    556 
    557     UErrorCode status = U_ZERO_ERROR;
    558     ScopedResourceBundle root(ures_open(NULL, localeName.c_str(), &status));
    559     if (U_FAILURE(status)) {
    560         LOGE("Error getting ICU resource bundle: %s", u_errorName(status));
    561         return JNI_FALSE;
    562     }
    563 
    564     ScopedResourceBundle calendar(ures_getByKey(root.get(), "calendar", NULL, &status));
    565     if (U_FAILURE(status)) {
    566         LOGE("Error getting ICU calendar resource bundle: %s", u_errorName(status));
    567         return JNI_FALSE;
    568     }
    569 
    570     ScopedResourceBundle gregorian(ures_getByKey(calendar.get(), "gregorian", NULL, &status));
    571     if (U_FAILURE(status)) {
    572         LOGE("Error getting ICU gregorian resource bundle: %s", u_errorName(status));
    573         return JNI_FALSE;
    574     }
    575 
    576     int firstDayVals[] = { 0, 0 };
    577     if (getDayIntVector(env, gregorian.get(), firstDayVals)) {
    578         setIntegerField(env, localeData, "firstDayOfWeek", firstDayVals[0]);
    579         setIntegerField(env, localeData, "minimalDaysInFirstWeek", firstDayVals[1]);
    580     }
    581 
    582     jobjectArray amPmMarkers = getAmPmMarkers(env, gregorian.get());
    583     setStringArrayField(env, localeData, "amPm", amPmMarkers);
    584     env->DeleteLocalRef(amPmMarkers);
    585 
    586     jobjectArray eras = getEras(env, gregorian.get());
    587     setStringArrayField(env, localeData, "eras", eras);
    588     env->DeleteLocalRef(eras);
    589 
    590     ScopedResourceBundle dayNames(ures_getByKey(gregorian.get(), "dayNames", NULL, &status));
    591     ScopedResourceBundle monthNames(ures_getByKey(gregorian.get(), "monthNames", NULL, &status));
    592 
    593     // Get the regular month and weekday names.
    594     jobjectArray longMonthNames = getNames(env, monthNames.get(), true, REGULAR, LONG);
    595     jobjectArray shortMonthNames = getNames(env, monthNames.get(), true, REGULAR, SHORT);
    596     jobjectArray longWeekdayNames = getNames(env, dayNames.get(), false, REGULAR, LONG);
    597     jobjectArray shortWeekdayNames = getNames(env, dayNames.get(), false, REGULAR, SHORT);
    598     setStringArrayField(env, localeData, "longMonthNames", longMonthNames);
    599     setStringArrayField(env, localeData, "shortMonthNames", shortMonthNames);
    600     setStringArrayField(env, localeData, "longWeekdayNames", longWeekdayNames);
    601     setStringArrayField(env, localeData, "shortWeekdayNames", shortWeekdayNames);
    602 
    603     // Get the stand-alone month and weekday names. If they're not available (as they aren't for
    604     // English), we reuse the regular names. If we returned null to Java, the usual fallback
    605     // mechanisms would come into play and we'd end up with the bogus stand-alone names from the
    606     // root locale ("1" for January, and so on).
    607     jobjectArray longStandAloneMonthNames = getNames(env, monthNames.get(), true, STAND_ALONE, LONG);
    608     if (longStandAloneMonthNames == NULL) {
    609         longStandAloneMonthNames = longMonthNames;
    610     }
    611     jobjectArray shortStandAloneMonthNames = getNames(env, monthNames.get(), true, STAND_ALONE, SHORT);
    612     if (shortStandAloneMonthNames == NULL) {
    613         shortStandAloneMonthNames = shortMonthNames;
    614     }
    615     jobjectArray longStandAloneWeekdayNames = getNames(env, dayNames.get(), false, STAND_ALONE, LONG);
    616     if (longStandAloneWeekdayNames == NULL) {
    617         longStandAloneWeekdayNames = longWeekdayNames;
    618     }
    619     jobjectArray shortStandAloneWeekdayNames = getNames(env, dayNames.get(), false, STAND_ALONE, SHORT);
    620     if (shortStandAloneWeekdayNames == NULL) {
    621         shortStandAloneWeekdayNames = shortWeekdayNames;
    622     }
    623     setStringArrayField(env, localeData, "longStandAloneMonthNames", longStandAloneMonthNames);
    624     setStringArrayField(env, localeData, "shortStandAloneMonthNames", shortStandAloneMonthNames);
    625     setStringArrayField(env, localeData, "longStandAloneWeekdayNames", longStandAloneWeekdayNames);
    626     setStringArrayField(env, localeData, "shortStandAloneWeekdayNames", shortStandAloneWeekdayNames);
    627 
    628     ScopedResourceBundle dateTimePatterns(ures_getByKey(gregorian.get(), "DateTimePatterns", NULL, &status));
    629     if (U_SUCCESS(status)) {
    630         setStringField(env, localeData, "fullTimeFormat", dateTimePatterns.get(), 0);
    631         setStringField(env, localeData, "longTimeFormat", dateTimePatterns.get(), 1);
    632         setStringField(env, localeData, "mediumTimeFormat", dateTimePatterns.get(), 2);
    633         setStringField(env, localeData, "shortTimeFormat", dateTimePatterns.get(), 3);
    634         setStringField(env, localeData, "fullDateFormat", dateTimePatterns.get(), 4);
    635         setStringField(env, localeData, "longDateFormat", dateTimePatterns.get(), 5);
    636         setStringField(env, localeData, "mediumDateFormat", dateTimePatterns.get(), 6);
    637         setStringField(env, localeData, "shortDateFormat", dateTimePatterns.get(), 7);
    638     }
    639     status = U_ZERO_ERROR;
    640 
    641     // For numberPatterns and symbols.
    642     ScopedResourceBundle numberElements(ures_getByKey(root.get(), "NumberElements", NULL, &status));
    643     if (U_SUCCESS(status)) {
    644         setNumberElements(env, localeData, numberElements.get());
    645     }
    646     status = U_ZERO_ERROR;
    647 
    648     jstring countryCode = env->NewStringUTF(Locale::createFromName(localeName.c_str()).getCountry());
    649     jstring internationalCurrencySymbol = ICU_getCurrencyCode(env, NULL, countryCode);
    650     env->DeleteLocalRef(countryCode);
    651     countryCode = NULL;
    652 
    653     jstring currencySymbol = NULL;
    654     if (internationalCurrencySymbol != NULL) {
    655         currencySymbol = ICU_getCurrencySymbol(env, NULL, locale, internationalCurrencySymbol);
    656     } else {
    657         internationalCurrencySymbol = env->NewStringUTF("XXX");
    658     }
    659     if (currencySymbol == NULL) {
    660         // This is the UTF-8 encoding of U+00A4 (CURRENCY SIGN).
    661         currencySymbol = env->NewStringUTF("\xc2\xa4");
    662     }
    663     setStringField(env, localeData, "currencySymbol", currencySymbol);
    664     setStringField(env, localeData, "internationalCurrencySymbol", internationalCurrencySymbol);
    665 
    666     return JNI_TRUE;
    667 }
    668 
    669 static jstring ICU_toLowerCase(JNIEnv* env, jclass, jstring javaString, jstring localeName) {
    670     ScopedJavaUnicodeString scopedString(env, javaString);
    671     UnicodeString& s(scopedString.unicodeString());
    672     UnicodeString original(s);
    673     s.toLower(Locale::createFromName(ScopedUtfChars(env, localeName).c_str()));
    674     return s == original ? javaString : env->NewString(s.getBuffer(), s.length());
    675 }
    676 
    677 static jstring ICU_toUpperCase(JNIEnv* env, jclass, jstring javaString, jstring localeName) {
    678     ScopedJavaUnicodeString scopedString(env, javaString);
    679     UnicodeString& s(scopedString.unicodeString());
    680     UnicodeString original(s);
    681     s.toUpper(Locale::createFromName(ScopedUtfChars(env, localeName).c_str()));
    682     return s == original ? javaString : env->NewString(s.getBuffer(), s.length());
    683 }
    684 
    685 static jstring versionString(JNIEnv* env, const UVersionInfo& version) {
    686     char versionString[U_MAX_VERSION_STRING_LENGTH];
    687     u_versionToString(const_cast<UVersionInfo&>(version), &versionString[0]);
    688     return env->NewStringUTF(versionString);
    689 }
    690 
    691 static jstring ICU_getIcuVersion(JNIEnv* env, jclass) {
    692     UVersionInfo icuVersion;
    693     u_getVersion(icuVersion);
    694     return versionString(env, icuVersion);
    695 }
    696 
    697 static jstring ICU_getUnicodeVersion(JNIEnv* env, jclass) {
    698     UVersionInfo unicodeVersion;
    699     u_getUnicodeVersion(unicodeVersion);
    700     return versionString(env, unicodeVersion);
    701 }
    702 
    703 
    704 struct EnumerationCounter {
    705     const size_t count;
    706     EnumerationCounter(size_t count) : count(count) {}
    707     size_t operator()() { return count; }
    708 };
    709 struct EnumerationGetter {
    710     UEnumeration* e;
    711     UErrorCode* status;
    712     EnumerationGetter(UEnumeration* e, UErrorCode* status) : e(e), status(status) {}
    713     const UChar* operator()(int32_t* charCount) { return uenum_unext(e, charCount, status); }
    714 };
    715 static jobject ICU_getAvailableCurrencyCodes(JNIEnv* env, jclass) {
    716     UErrorCode status = U_ZERO_ERROR;
    717     UEnumeration* e(ucurr_openISOCurrencies(UCURR_COMMON|UCURR_NON_DEPRECATED, &status));
    718     EnumerationCounter counter(uenum_count(e, &status));
    719     EnumerationGetter getter(e, &status);
    720     jobject result = toStringArray16(env, &counter, &getter);
    721     maybeThrowIcuException(env, status);
    722     uenum_close(e);
    723     return result;
    724 }
    725 
    726 static JNINativeMethod gMethods[] = {
    727     NATIVE_METHOD(ICU, addLikelySubtags, "(Ljava/lang/String;)Ljava/lang/String;"),
    728     NATIVE_METHOD(ICU, getAvailableBreakIteratorLocalesNative, "()[Ljava/lang/String;"),
    729     NATIVE_METHOD(ICU, getAvailableCalendarLocalesNative, "()[Ljava/lang/String;"),
    730     NATIVE_METHOD(ICU, getAvailableCollatorLocalesNative, "()[Ljava/lang/String;"),
    731     NATIVE_METHOD(ICU, getAvailableCurrencyCodes, "()[Ljava/lang/String;"),
    732     NATIVE_METHOD(ICU, getAvailableDateFormatLocalesNative, "()[Ljava/lang/String;"),
    733     NATIVE_METHOD(ICU, getAvailableLocalesNative, "()[Ljava/lang/String;"),
    734     NATIVE_METHOD(ICU, getAvailableNumberFormatLocalesNative, "()[Ljava/lang/String;"),
    735     NATIVE_METHOD(ICU, getCurrencyCode, "(Ljava/lang/String;)Ljava/lang/String;"),
    736     NATIVE_METHOD(ICU, getCurrencyDisplayName, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
    737     NATIVE_METHOD(ICU, getCurrencyFractionDigits, "(Ljava/lang/String;)I"),
    738     NATIVE_METHOD(ICU, getCurrencySymbol, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
    739     NATIVE_METHOD(ICU, getDisplayCountryNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
    740     NATIVE_METHOD(ICU, getDisplayLanguageNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
    741     NATIVE_METHOD(ICU, getDisplayVariantNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
    742     NATIVE_METHOD(ICU, getISO3CountryNative, "(Ljava/lang/String;)Ljava/lang/String;"),
    743     NATIVE_METHOD(ICU, getISO3LanguageNative, "(Ljava/lang/String;)Ljava/lang/String;"),
    744     NATIVE_METHOD(ICU, getISOCountriesNative, "()[Ljava/lang/String;"),
    745     NATIVE_METHOD(ICU, getISOLanguagesNative, "()[Ljava/lang/String;"),
    746     NATIVE_METHOD(ICU, getIcuVersion, "()Ljava/lang/String;"),
    747     NATIVE_METHOD(ICU, getScript, "(Ljava/lang/String;)Ljava/lang/String;"),
    748     NATIVE_METHOD(ICU, getUnicodeVersion, "()Ljava/lang/String;"),
    749     NATIVE_METHOD(ICU, initLocaleDataImpl, "(Ljava/lang/String;Llibcore/icu/LocaleData;)Z"),
    750     NATIVE_METHOD(ICU, toLowerCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
    751     NATIVE_METHOD(ICU, toUpperCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
    752 };
    753 int register_libcore_icu_ICU(JNIEnv* env) {
    754     std::string path;
    755     path = u_getDataDirectory();
    756     path += "/";
    757     path += U_ICUDATA_NAME;
    758     path += ".dat";
    759 
    760     #define FAIL_WITH_STRERROR(s) \
    761         LOGE("Couldn't " s " '%s': %s", path.c_str(), strerror(errno)); \
    762         return -1;
    763     #define MAYBE_FAIL_WITH_ICU_ERROR(s) \
    764         if (status != U_ZERO_ERROR) {\
    765             LOGE("Couldn't initialize ICU (" s "): %s (%s)", u_errorName(status), path.c_str()); \
    766             return -1; \
    767         }
    768 
    769     // Open the file and get its length.
    770     ScopedFd fd(open(path.c_str(), O_RDONLY));
    771     if (fd.get() == -1) {
    772         FAIL_WITH_STRERROR("open");
    773     }
    774     struct stat sb;
    775     if (fstat(fd.get(), &sb) == -1) {
    776         FAIL_WITH_STRERROR("stat");
    777     }
    778 
    779     // Map it.
    780     void* data = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd.get(), 0);
    781     if (data == MAP_FAILED) {
    782         FAIL_WITH_STRERROR("mmap");
    783     }
    784 
    785     // Tell the kernel that accesses are likely to be random rather than sequential.
    786     if (madvise(data, sb.st_size, MADV_RANDOM) == -1) {
    787         FAIL_WITH_STRERROR("madvise(MADV_RANDOM)");
    788     }
    789 
    790     // Tell ICU to use our memory-mapped data.
    791     UErrorCode status = U_ZERO_ERROR;
    792     udata_setCommonData(data, &status);
    793     MAYBE_FAIL_WITH_ICU_ERROR("udata_setCommonData");
    794     // Tell ICU it can *only* use our memory-mapped data.
    795     udata_setFileAccess(UDATA_NO_FILES, &status);
    796     MAYBE_FAIL_WITH_ICU_ERROR("udata_setFileAccess");
    797 
    798     // Failures to find the ICU data tend to be somewhat obscure because ICU loads its data on first
    799     // use, which can be anywhere. Force initialization up front so we can report a nice clear error
    800     // and bail.
    801     u_init(&status);
    802     MAYBE_FAIL_WITH_ICU_ERROR("u_init");
    803     return jniRegisterNativeMethods(env, "libcore/icu/ICU", gMethods, NELEM(gMethods));
    804 }
    805