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("XXX");
    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("XXX");
    153     }
    154 
    155     int32_t charCount;
    156     const jchar* chars = ures_getString(currencyId.get(), &charCount, &status);
    157     return (charCount == 0) ? env->NewStringUTF("XXX") : 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 void setIntegerField(JNIEnv* env, jobject obj, const char* fieldName, int value) {
    273     ScopedLocalRef<jobject> integerValue(env, integerValueOf(env, value));
    274     jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "Ljava/lang/Integer;");
    275     env->SetObjectField(obj, fid, integerValue.get());
    276 }
    277 
    278 static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, jstring value) {
    279     jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "Ljava/lang/String;");
    280     env->SetObjectField(obj, fid, value);
    281     env->DeleteLocalRef(value);
    282 }
    283 
    284 static void setStringArrayField(JNIEnv* env, jobject obj, const char* fieldName, jobjectArray value) {
    285     jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "[Ljava/lang/String;");
    286     env->SetObjectField(obj, fid, value);
    287 }
    288 
    289 static void setStringArrayField(JNIEnv* env, jobject obj, const char* fieldName, const UnicodeString* valueArray, int32_t size) {
    290     ScopedLocalRef<jobjectArray> result(env, env->NewObjectArray(size, JniConstants::stringClass, NULL));
    291     for (int32_t i = 0; i < size ; i++) {
    292         ScopedLocalRef<jstring> s(env, env->NewString(valueArray[i].getBuffer(),valueArray[i].length()));
    293         if (env->ExceptionCheck()) {
    294             return;
    295         }
    296         env->SetObjectArrayElement(result.get(), i, s.get());
    297         if (env->ExceptionCheck()) {
    298             return;
    299         }
    300     }
    301     setStringArrayField(env, obj, fieldName, result.get());
    302 }
    303 
    304 static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, UResourceBundle* bundle, int index) {
    305     UErrorCode status = U_ZERO_ERROR;
    306     int charCount;
    307     const UChar* chars = ures_getStringByIndex(bundle, index, &charCount, &status);
    308     if (U_SUCCESS(status)) {
    309         setStringField(env, obj, fieldName, env->NewString(chars, charCount));
    310     } else {
    311         ALOGE("Error setting String field %s from ICU resource: %s", fieldName, u_errorName(status));
    312     }
    313 }
    314 
    315 static void setCharField(JNIEnv* env, jobject obj, const char* fieldName, const UnicodeString& value) {
    316     if (value.length() == 0) {
    317         return;
    318     }
    319     jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "C");
    320     env->SetCharField(obj, fid, value.charAt(0));
    321 }
    322 
    323 static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, const UnicodeString& value) {
    324     const UChar* chars = value.getBuffer();
    325     setStringField(env, obj, fieldName, env->NewString(chars, value.length()));
    326 }
    327 
    328 static void setNumberPatterns(JNIEnv* env, jobject obj, jstring locale) {
    329     UErrorCode status = U_ZERO_ERROR;
    330     Locale localeObj = getLocale(env, locale);
    331 
    332     UnicodeString pattern;
    333     UniquePtr<DecimalFormat> fmt(static_cast<DecimalFormat*>(NumberFormat::createInstance(localeObj, UNUM_CURRENCY, status)));
    334     pattern = fmt->toPattern(pattern.remove());
    335     setStringField(env, obj, "currencyPattern", pattern);
    336 
    337     fmt.reset(static_cast<DecimalFormat*>(NumberFormat::createInstance(localeObj, UNUM_DECIMAL, status)));
    338     pattern = fmt->toPattern(pattern.remove());
    339     setStringField(env, obj, "numberPattern", pattern);
    340 
    341     fmt.reset(static_cast<DecimalFormat*>(NumberFormat::createInstance(localeObj, UNUM_PERCENT, status)));
    342     pattern = fmt->toPattern(pattern.remove());
    343     setStringField(env, obj, "percentPattern", pattern);
    344 }
    345 
    346 static void setDecimalFormatSymbolsData(JNIEnv* env, jobject obj, jstring locale) {
    347     UErrorCode status = U_ZERO_ERROR;
    348     Locale localeObj = getLocale(env, locale);
    349     DecimalFormatSymbols dfs(localeObj, status);
    350 
    351     setCharField(env, obj, "decimalSeparator", dfs.getSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol));
    352     setCharField(env, obj, "groupingSeparator", dfs.getSymbol(DecimalFormatSymbols::kGroupingSeparatorSymbol));
    353     setCharField(env, obj, "patternSeparator", dfs.getSymbol(DecimalFormatSymbols::kPatternSeparatorSymbol));
    354     setCharField(env, obj, "percent", dfs.getSymbol(DecimalFormatSymbols::kPercentSymbol));
    355     setCharField(env, obj, "perMill", dfs.getSymbol(DecimalFormatSymbols::kPerMillSymbol));
    356     setCharField(env, obj, "monetarySeparator", dfs.getSymbol(DecimalFormatSymbols::kMonetarySeparatorSymbol));
    357     setCharField(env, obj, "minusSign", dfs.getSymbol(DecimalFormatSymbols:: kMinusSignSymbol));
    358     setStringField(env, obj, "exponentSeparator", dfs.getSymbol(DecimalFormatSymbols::kExponentialSymbol));
    359     setStringField(env, obj, "infinity", dfs.getSymbol(DecimalFormatSymbols::kInfinitySymbol));
    360     setStringField(env, obj, "NaN", dfs.getSymbol(DecimalFormatSymbols::kNaNSymbol));
    361     setCharField(env, obj, "zeroDigit", dfs.getSymbol(DecimalFormatSymbols::kZeroDigitSymbol));
    362 }
    363 
    364 static jboolean ICU_initLocaleDataImpl(JNIEnv* env, jclass, jstring locale, jobject localeData) {
    365     ScopedUtfChars localeName(env, locale);
    366     if (localeName.c_str() == NULL) {
    367         return JNI_FALSE;
    368     }
    369 
    370     // Get DateTimePatterns
    371     UErrorCode status;
    372     char currentLocale[ULOC_FULLNAME_CAPACITY];
    373     int32_t localeNameLen = 0;
    374     if (localeName.size() >= ULOC_FULLNAME_CAPACITY) {
    375         return JNI_FALSE;  // Exceed ICU defined limit of the whole locale ID.
    376     }
    377     strcpy(currentLocale, localeName.c_str());
    378     do {
    379         status = U_ZERO_ERROR;
    380         ScopedResourceBundle root(ures_open(NULL, currentLocale, &status));
    381         if (U_FAILURE(status)) {
    382             if (localeNameLen == 0) {
    383                 break;  // No parent locale, report this error outside the loop.
    384             } else {
    385                 status = U_ZERO_ERROR;
    386                 continue;  // get parent locale.
    387             }
    388         }
    389         ScopedResourceBundle calendar(ures_getByKey(root.get(), "calendar", NULL, &status));
    390         if (U_FAILURE(status)) {
    391             status = U_ZERO_ERROR;
    392             continue;  // get parent locale.
    393         }
    394 
    395         ScopedResourceBundle gregorian(ures_getByKey(calendar.get(), "gregorian", NULL, &status));
    396         if (U_FAILURE(status)) {
    397             status = U_ZERO_ERROR;
    398             continue;  // get parent locale.
    399         }
    400         ScopedResourceBundle dateTimePatterns(ures_getByKey(gregorian.get(), "DateTimePatterns", NULL, &status));
    401         if (U_SUCCESS(status)) {
    402             setStringField(env, localeData, "fullTimeFormat", dateTimePatterns.get(), 0);
    403             setStringField(env, localeData, "longTimeFormat", dateTimePatterns.get(), 1);
    404             setStringField(env, localeData, "mediumTimeFormat", dateTimePatterns.get(), 2);
    405             setStringField(env, localeData, "shortTimeFormat", dateTimePatterns.get(), 3);
    406             setStringField(env, localeData, "fullDateFormat", dateTimePatterns.get(), 4);
    407             setStringField(env, localeData, "longDateFormat", dateTimePatterns.get(), 5);
    408             setStringField(env, localeData, "mediumDateFormat", dateTimePatterns.get(), 6);
    409             setStringField(env, localeData, "shortDateFormat", dateTimePatterns.get(), 7);
    410             break;
    411         } else {
    412             status = U_ZERO_ERROR;  // get parent locale.
    413         }
    414     } while((localeNameLen = uloc_getParent(currentLocale, currentLocale, sizeof(currentLocale), &status)) >= 0);
    415     if (U_FAILURE(status)) {
    416         ALOGE("Error getting ICU resource bundle: %s", u_errorName(status));
    417         return JNI_FALSE;
    418     }
    419 
    420     status = U_ZERO_ERROR;
    421     Locale localeObj = getLocale(env, locale);
    422 
    423     UniquePtr<Calendar> cal(Calendar::createInstance(localeObj, status));
    424     if (U_FAILURE(status)) {
    425         return JNI_FALSE;
    426     }
    427     setIntegerField(env, localeData, "firstDayOfWeek", cal->getFirstDayOfWeek());
    428     setIntegerField(env, localeData, "minimalDaysInFirstWeek", cal->getMinimalDaysInFirstWeek());
    429 
    430     // Get DateFormatSymbols
    431     status = U_ZERO_ERROR;
    432     DateFormatSymbols dateFormatSym(localeObj, status);
    433     if (U_FAILURE(status)) {
    434         return JNI_FALSE;
    435     }
    436     int32_t count = 0;
    437     // Get AM/PM marker
    438     const UnicodeString* amPmStrs = dateFormatSym.getAmPmStrings(count);
    439     setStringArrayField(env, localeData, "amPm", amPmStrs, count);
    440     const UnicodeString* erasStrs = dateFormatSym.getEras(count);
    441     setStringArrayField(env, localeData, "eras", erasStrs, count);
    442 
    443     const UnicodeString* longMonthNames =
    444        dateFormatSym.getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
    445     setStringArrayField(env, localeData, "longMonthNames", longMonthNames, count);
    446     const UnicodeString* shortMonthNames =
    447         dateFormatSym.getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
    448     setStringArrayField(env, localeData, "shortMonthNames", shortMonthNames, count);
    449     const UnicodeString* longWeekdayNames =
    450         dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
    451     setStringArrayField(env, localeData, "longWeekdayNames", longWeekdayNames, count);
    452     const UnicodeString* shortWeekdayNames =
    453         dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
    454     setStringArrayField(env, localeData, "shortWeekdayNames", shortWeekdayNames, count);
    455 
    456     const UnicodeString* longStandAloneMonthNames =
    457         dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
    458     setStringArrayField(env, localeData, "longStandAloneMonthNames", longStandAloneMonthNames, count);
    459     const UnicodeString* shortStandAloneMonthNames =
    460         dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
    461     setStringArrayField(env, localeData, "shortStandAloneMonthNames", shortStandAloneMonthNames, count);
    462     const UnicodeString* longStandAloneWeekdayNames =
    463         dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
    464     setStringArrayField(env, localeData, "longStandAloneWeekdayNames", longStandAloneWeekdayNames, count);
    465     const UnicodeString* shortStandAloneWeekdayNames =
    466         dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
    467     setStringArrayField(env, localeData, "shortStandAloneWeekdayNames", shortStandAloneWeekdayNames, count);
    468 
    469     status = U_ZERO_ERROR;
    470 
    471     // For numberPatterns and symbols.
    472     setNumberPatterns(env, localeData, locale);
    473     setDecimalFormatSymbolsData(env, localeData, locale);
    474 
    475     jstring countryCode = env->NewStringUTF(Locale::createFromName(localeName.c_str()).getCountry());
    476     jstring internationalCurrencySymbol = ICU_getCurrencyCode(env, NULL, countryCode);
    477     env->DeleteLocalRef(countryCode);
    478     countryCode = NULL;
    479 
    480     jstring currencySymbol = NULL;
    481     if (internationalCurrencySymbol != NULL) {
    482         currencySymbol = ICU_getCurrencySymbol(env, NULL, locale, internationalCurrencySymbol);
    483     } else {
    484         internationalCurrencySymbol = env->NewStringUTF("XXX");
    485     }
    486     if (currencySymbol == NULL) {
    487         // This is the UTF-8 encoding of U+00A4 (CURRENCY SIGN).
    488         currencySymbol = env->NewStringUTF("\xc2\xa4");
    489     }
    490     setStringField(env, localeData, "currencySymbol", currencySymbol);
    491     setStringField(env, localeData, "internationalCurrencySymbol", internationalCurrencySymbol);
    492 
    493     return JNI_TRUE;
    494 }
    495 
    496 static jstring ICU_toLowerCase(JNIEnv* env, jclass, jstring javaString, jstring localeName) {
    497     ScopedJavaUnicodeString scopedString(env, javaString);
    498     UnicodeString& s(scopedString.unicodeString());
    499     UnicodeString original(s);
    500     s.toLower(Locale::createFromName(ScopedUtfChars(env, localeName).c_str()));
    501     return s == original ? javaString : env->NewString(s.getBuffer(), s.length());
    502 }
    503 
    504 static jstring ICU_toUpperCase(JNIEnv* env, jclass, jstring javaString, jstring localeName) {
    505     ScopedJavaUnicodeString scopedString(env, javaString);
    506     UnicodeString& s(scopedString.unicodeString());
    507     UnicodeString original(s);
    508     s.toUpper(Locale::createFromName(ScopedUtfChars(env, localeName).c_str()));
    509     return s == original ? javaString : env->NewString(s.getBuffer(), s.length());
    510 }
    511 
    512 static jstring versionString(JNIEnv* env, const UVersionInfo& version) {
    513     char versionString[U_MAX_VERSION_STRING_LENGTH];
    514     u_versionToString(const_cast<UVersionInfo&>(version), &versionString[0]);
    515     return env->NewStringUTF(versionString);
    516 }
    517 
    518 static jstring ICU_getIcuVersion(JNIEnv* env, jclass) {
    519     UVersionInfo icuVersion;
    520     u_getVersion(icuVersion);
    521     return versionString(env, icuVersion);
    522 }
    523 
    524 static jstring ICU_getUnicodeVersion(JNIEnv* env, jclass) {
    525     UVersionInfo unicodeVersion;
    526     u_getUnicodeVersion(unicodeVersion);
    527     return versionString(env, unicodeVersion);
    528 }
    529 
    530 
    531 struct EnumerationCounter {
    532     const size_t count;
    533     EnumerationCounter(size_t count) : count(count) {}
    534     size_t operator()() { return count; }
    535 };
    536 struct EnumerationGetter {
    537     UEnumeration* e;
    538     UErrorCode* status;
    539     EnumerationGetter(UEnumeration* e, UErrorCode* status) : e(e), status(status) {}
    540     const UChar* operator()(int32_t* charCount) { return uenum_unext(e, charCount, status); }
    541 };
    542 static jobject ICU_getAvailableCurrencyCodes(JNIEnv* env, jclass) {
    543     UErrorCode status = U_ZERO_ERROR;
    544     UEnumeration* e(ucurr_openISOCurrencies(UCURR_COMMON|UCURR_NON_DEPRECATED, &status));
    545     EnumerationCounter counter(uenum_count(e, &status));
    546     EnumerationGetter getter(e, &status);
    547     jobject result = toStringArray16(env, &counter, &getter);
    548     maybeThrowIcuException(env, status);
    549     uenum_close(e);
    550     return result;
    551 }
    552 
    553 static JNINativeMethod gMethods[] = {
    554     NATIVE_METHOD(ICU, addLikelySubtags, "(Ljava/lang/String;)Ljava/lang/String;"),
    555     NATIVE_METHOD(ICU, getAvailableBreakIteratorLocalesNative, "()[Ljava/lang/String;"),
    556     NATIVE_METHOD(ICU, getAvailableCalendarLocalesNative, "()[Ljava/lang/String;"),
    557     NATIVE_METHOD(ICU, getAvailableCollatorLocalesNative, "()[Ljava/lang/String;"),
    558     NATIVE_METHOD(ICU, getAvailableCurrencyCodes, "()[Ljava/lang/String;"),
    559     NATIVE_METHOD(ICU, getAvailableDateFormatLocalesNative, "()[Ljava/lang/String;"),
    560     NATIVE_METHOD(ICU, getAvailableLocalesNative, "()[Ljava/lang/String;"),
    561     NATIVE_METHOD(ICU, getAvailableNumberFormatLocalesNative, "()[Ljava/lang/String;"),
    562     NATIVE_METHOD(ICU, getCurrencyCode, "(Ljava/lang/String;)Ljava/lang/String;"),
    563     NATIVE_METHOD(ICU, getCurrencyDisplayName, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
    564     NATIVE_METHOD(ICU, getCurrencyFractionDigits, "(Ljava/lang/String;)I"),
    565     NATIVE_METHOD(ICU, getCurrencySymbol, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
    566     NATIVE_METHOD(ICU, getDisplayCountryNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
    567     NATIVE_METHOD(ICU, getDisplayLanguageNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
    568     NATIVE_METHOD(ICU, getDisplayVariantNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
    569     NATIVE_METHOD(ICU, getISO3CountryNative, "(Ljava/lang/String;)Ljava/lang/String;"),
    570     NATIVE_METHOD(ICU, getISO3LanguageNative, "(Ljava/lang/String;)Ljava/lang/String;"),
    571     NATIVE_METHOD(ICU, getISOCountriesNative, "()[Ljava/lang/String;"),
    572     NATIVE_METHOD(ICU, getISOLanguagesNative, "()[Ljava/lang/String;"),
    573     NATIVE_METHOD(ICU, getIcuVersion, "()Ljava/lang/String;"),
    574     NATIVE_METHOD(ICU, getScript, "(Ljava/lang/String;)Ljava/lang/String;"),
    575     NATIVE_METHOD(ICU, getUnicodeVersion, "()Ljava/lang/String;"),
    576     NATIVE_METHOD(ICU, initLocaleDataImpl, "(Ljava/lang/String;Llibcore/icu/LocaleData;)Z"),
    577     NATIVE_METHOD(ICU, toLowerCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
    578     NATIVE_METHOD(ICU, toUpperCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
    579 };
    580 void register_libcore_icu_ICU(JNIEnv* env) {
    581     std::string path;
    582     path = u_getDataDirectory();
    583     path += "/";
    584     path += U_ICUDATA_NAME;
    585     path += ".dat";
    586 
    587     #define FAIL_WITH_STRERROR(s) \
    588         ALOGE("Couldn't " s " '%s': %s", path.c_str(), strerror(errno)); \
    589         abort();
    590     #define MAYBE_FAIL_WITH_ICU_ERROR(s) \
    591         if (status != U_ZERO_ERROR) {\
    592             ALOGE("Couldn't initialize ICU (" s "): %s (%s)", u_errorName(status), path.c_str()); \
    593             abort(); \
    594         }
    595 
    596     // Open the file and get its length.
    597     ScopedFd fd(open(path.c_str(), O_RDONLY));
    598     if (fd.get() == -1) {
    599         FAIL_WITH_STRERROR("open");
    600     }
    601     struct stat sb;
    602     if (fstat(fd.get(), &sb) == -1) {
    603         FAIL_WITH_STRERROR("stat");
    604     }
    605 
    606     // Map it.
    607     void* data = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd.get(), 0);
    608     if (data == MAP_FAILED) {
    609         FAIL_WITH_STRERROR("mmap");
    610     }
    611 
    612     // Tell the kernel that accesses are likely to be random rather than sequential.
    613     if (madvise(data, sb.st_size, MADV_RANDOM) == -1) {
    614         FAIL_WITH_STRERROR("madvise(MADV_RANDOM)");
    615     }
    616 
    617     // Tell ICU to use our memory-mapped data.
    618     UErrorCode status = U_ZERO_ERROR;
    619     udata_setCommonData(data, &status);
    620     MAYBE_FAIL_WITH_ICU_ERROR("udata_setCommonData");
    621     // Tell ICU it can *only* use our memory-mapped data.
    622     udata_setFileAccess(UDATA_NO_FILES, &status);
    623     MAYBE_FAIL_WITH_ICU_ERROR("udata_setFileAccess");
    624 
    625     // Failures to find the ICU data tend to be somewhat obscure because ICU loads its data on first
    626     // use, which can be anywhere. Force initialization up front so we can report a nice clear error
    627     // and bail.
    628     u_init(&status);
    629     MAYBE_FAIL_WITH_ICU_ERROR("u_init");
    630     jniRegisterNativeMethods(env, "libcore/icu/ICU", gMethods, NELEM(gMethods));
    631 }
    632