libcore_icu_ICU.cpp revision 73dc486a74a67ce375e3d90dcfaa6b5255b7c0da 
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
62class ScopedResourceBundle {
63public:
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
77private:
78    UResourceBundle* mBundle;
79
80    // Disallow copy and assignment.
81    ScopedResourceBundle(const ScopedResourceBundle&);
82    void operator=(const ScopedResourceBundle&);
83};
84
85Locale getLocale(JNIEnv* env, jstring localeName) {
86    return Locale::createFromName(ScopedUtfChars(env, localeName).c_str());
87}
88
89static 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
100static 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
111static 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
118static 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
160static 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
177static 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
206static 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
214static 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
222static 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
230static jstring ICU_getISO3CountryNative(JNIEnv* env, jclass, jstring locale) {
231    Locale loc = getLocale(env, locale);
232    return env->NewStringUTF(loc.getISO3Country());
233}
234
235static jstring ICU_getISO3LanguageNative(JNIEnv* env, jclass, jstring locale) {
236    Locale loc = getLocale(env, locale);
237    return env->NewStringUTF(loc.getISO3Language());
238}
239
240static jobjectArray ICU_getISOCountriesNative(JNIEnv* env, jclass) {
241    return toStringArray(env, Locale::getISOCountries());
242}
243
244static jobjectArray ICU_getISOLanguagesNative(JNIEnv* env, jclass) {
245    return toStringArray(env, Locale::getISOLanguages());
246}
247
248static jobjectArray ICU_getAvailableLocalesNative(JNIEnv* env, jclass) {
249    return toStringArray(env, uloc_countAvailable, uloc_getAvailable);
250}
251
252static jobjectArray ICU_getAvailableBreakIteratorLocalesNative(JNIEnv* env, jclass) {
253    return toStringArray(env, ubrk_countAvailable, ubrk_getAvailable);
254}
255
256static jobjectArray ICU_getAvailableCalendarLocalesNative(JNIEnv* env, jclass) {
257    return toStringArray(env, ucal_countAvailable, ucal_getAvailable);
258}
259
260static jobjectArray ICU_getAvailableCollatorLocalesNative(JNIEnv* env, jclass) {
261    return toStringArray(env, ucol_countAvailable, ucol_getAvailable);
262}
263
264static jobjectArray ICU_getAvailableDateFormatLocalesNative(JNIEnv* env, jclass) {
265    return toStringArray(env, udat_countAvailable, udat_getAvailable);
266}
267
268static jobjectArray ICU_getAvailableNumberFormatLocalesNative(JNIEnv* env, jclass) {
269    return toStringArray(env, unum_countAvailable, unum_getAvailable);
270}
271
272static 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
278static 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
284static 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
289static 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
304static 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
315static 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
323static 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
328static 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
346static 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
364static 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* tinyMonthNames =
450        dateFormatSym.getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
451    setStringArrayField(env, localeData, "tinyMonthNames", tinyMonthNames, count);
452    const UnicodeString* longWeekdayNames =
453        dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
454    setStringArrayField(env, localeData, "longWeekdayNames", longWeekdayNames, count);
455    const UnicodeString* shortWeekdayNames =
456        dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
457    setStringArrayField(env, localeData, "shortWeekdayNames", shortWeekdayNames, count);
458    const UnicodeString* tinyWeekdayNames =
459        dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
460    setStringArrayField(env, localeData, "tinyWeekdayNames", tinyWeekdayNames, count);
461
462    const UnicodeString* longStandAloneMonthNames =
463        dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
464    setStringArrayField(env, localeData, "longStandAloneMonthNames", longStandAloneMonthNames, count);
465    const UnicodeString* shortStandAloneMonthNames =
466        dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
467    setStringArrayField(env, localeData, "shortStandAloneMonthNames", shortStandAloneMonthNames, count);
468    const UnicodeString* tinyStandAloneMonthNames =
469        dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
470    setStringArrayField(env, localeData, "tinyStandAloneMonthNames", tinyStandAloneMonthNames, count);
471    const UnicodeString* longStandAloneWeekdayNames =
472        dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
473    setStringArrayField(env, localeData, "longStandAloneWeekdayNames", longStandAloneWeekdayNames, count);
474    const UnicodeString* shortStandAloneWeekdayNames =
475        dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
476    setStringArrayField(env, localeData, "shortStandAloneWeekdayNames", shortStandAloneWeekdayNames, count);
477    const UnicodeString* tinyStandAloneWeekdayNames =
478        dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
479    setStringArrayField(env, localeData, "tinyStandAloneWeekdayNames", tinyStandAloneWeekdayNames, count);
480
481    status = U_ZERO_ERROR;
482
483    // For numberPatterns and symbols.
484    setNumberPatterns(env, localeData, locale);
485    setDecimalFormatSymbolsData(env, localeData, locale);
486
487    jstring countryCode = env->NewStringUTF(Locale::createFromName(localeName.c_str()).getCountry());
488    jstring internationalCurrencySymbol = ICU_getCurrencyCode(env, NULL, countryCode);
489    env->DeleteLocalRef(countryCode);
490    countryCode = NULL;
491
492    jstring currencySymbol = NULL;
493    if (internationalCurrencySymbol != NULL) {
494        currencySymbol = ICU_getCurrencySymbol(env, NULL, locale, internationalCurrencySymbol);
495    } else {
496        internationalCurrencySymbol = env->NewStringUTF("XXX");
497    }
498    if (currencySymbol == NULL) {
499        // This is the UTF-8 encoding of U+00A4 (CURRENCY SIGN).
500        currencySymbol = env->NewStringUTF("\xc2\xa4");
501    }
502    setStringField(env, localeData, "currencySymbol", currencySymbol);
503    setStringField(env, localeData, "internationalCurrencySymbol", internationalCurrencySymbol);
504
505    return JNI_TRUE;
506}
507
508static jstring ICU_toLowerCase(JNIEnv* env, jclass, jstring javaString, jstring localeName) {
509    ScopedJavaUnicodeString scopedString(env, javaString);
510    UnicodeString& s(scopedString.unicodeString());
511    UnicodeString original(s);
512    s.toLower(Locale::createFromName(ScopedUtfChars(env, localeName).c_str()));
513    return s == original ? javaString : env->NewString(s.getBuffer(), s.length());
514}
515
516static jstring ICU_toUpperCase(JNIEnv* env, jclass, jstring javaString, jstring localeName) {
517    ScopedJavaUnicodeString scopedString(env, javaString);
518    UnicodeString& s(scopedString.unicodeString());
519    UnicodeString original(s);
520    s.toUpper(Locale::createFromName(ScopedUtfChars(env, localeName).c_str()));
521    return s == original ? javaString : env->NewString(s.getBuffer(), s.length());
522}
523
524static jstring versionString(JNIEnv* env, const UVersionInfo& version) {
525    char versionString[U_MAX_VERSION_STRING_LENGTH];
526    u_versionToString(const_cast<UVersionInfo&>(version), &versionString[0]);
527    return env->NewStringUTF(versionString);
528}
529
530static jstring ICU_getIcuVersion(JNIEnv* env, jclass) {
531    UVersionInfo icuVersion;
532    u_getVersion(icuVersion);
533    return versionString(env, icuVersion);
534}
535
536static jstring ICU_getUnicodeVersion(JNIEnv* env, jclass) {
537    UVersionInfo unicodeVersion;
538    u_getUnicodeVersion(unicodeVersion);
539    return versionString(env, unicodeVersion);
540}
541
542
543struct EnumerationCounter {
544    const size_t count;
545    EnumerationCounter(size_t count) : count(count) {}
546    size_t operator()() { return count; }
547};
548struct EnumerationGetter {
549    UEnumeration* e;
550    UErrorCode* status;
551    EnumerationGetter(UEnumeration* e, UErrorCode* status) : e(e), status(status) {}
552    const UChar* operator()(int32_t* charCount) { return uenum_unext(e, charCount, status); }
553};
554static jobject ICU_getAvailableCurrencyCodes(JNIEnv* env, jclass) {
555    UErrorCode status = U_ZERO_ERROR;
556    UEnumeration* e(ucurr_openISOCurrencies(UCURR_COMMON|UCURR_NON_DEPRECATED, &status));
557    EnumerationCounter counter(uenum_count(e, &status));
558    if (maybeThrowIcuException(env, "uenum_count", status)) {
559        return NULL;
560    }
561    EnumerationGetter getter(e, &status);
562    jobject result = toStringArray16(env, &counter, &getter);
563    maybeThrowIcuException(env, "uenum_unext", status);
564    uenum_close(e);
565    return result;
566}
567
568static JNINativeMethod gMethods[] = {
569    NATIVE_METHOD(ICU, addLikelySubtags, "(Ljava/lang/String;)Ljava/lang/String;"),
570    NATIVE_METHOD(ICU, getAvailableBreakIteratorLocalesNative, "()[Ljava/lang/String;"),
571    NATIVE_METHOD(ICU, getAvailableCalendarLocalesNative, "()[Ljava/lang/String;"),
572    NATIVE_METHOD(ICU, getAvailableCollatorLocalesNative, "()[Ljava/lang/String;"),
573    NATIVE_METHOD(ICU, getAvailableCurrencyCodes, "()[Ljava/lang/String;"),
574    NATIVE_METHOD(ICU, getAvailableDateFormatLocalesNative, "()[Ljava/lang/String;"),
575    NATIVE_METHOD(ICU, getAvailableLocalesNative, "()[Ljava/lang/String;"),
576    NATIVE_METHOD(ICU, getAvailableNumberFormatLocalesNative, "()[Ljava/lang/String;"),
577    NATIVE_METHOD(ICU, getCurrencyCode, "(Ljava/lang/String;)Ljava/lang/String;"),
578    NATIVE_METHOD(ICU, getCurrencyDisplayName, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
579    NATIVE_METHOD(ICU, getCurrencyFractionDigits, "(Ljava/lang/String;)I"),
580    NATIVE_METHOD(ICU, getCurrencySymbol, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
581    NATIVE_METHOD(ICU, getDisplayCountryNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
582    NATIVE_METHOD(ICU, getDisplayLanguageNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
583    NATIVE_METHOD(ICU, getDisplayVariantNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
584    NATIVE_METHOD(ICU, getISO3CountryNative, "(Ljava/lang/String;)Ljava/lang/String;"),
585    NATIVE_METHOD(ICU, getISO3LanguageNative, "(Ljava/lang/String;)Ljava/lang/String;"),
586    NATIVE_METHOD(ICU, getISOCountriesNative, "()[Ljava/lang/String;"),
587    NATIVE_METHOD(ICU, getISOLanguagesNative, "()[Ljava/lang/String;"),
588    NATIVE_METHOD(ICU, getIcuVersion, "()Ljava/lang/String;"),
589    NATIVE_METHOD(ICU, getScript, "(Ljava/lang/String;)Ljava/lang/String;"),
590    NATIVE_METHOD(ICU, getUnicodeVersion, "()Ljava/lang/String;"),
591    NATIVE_METHOD(ICU, initLocaleDataImpl, "(Ljava/lang/String;Llibcore/icu/LocaleData;)Z"),
592    NATIVE_METHOD(ICU, toLowerCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
593    NATIVE_METHOD(ICU, toUpperCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
594};
595void register_libcore_icu_ICU(JNIEnv* env) {
596    std::string path;
597    path = u_getDataDirectory();
598    path += "/";
599    path += U_ICUDATA_NAME;
600    path += ".dat";
601
602    #define FAIL_WITH_STRERROR(s) \
603        ALOGE("Couldn't " s " '%s': %s", path.c_str(), strerror(errno)); \
604        abort();
605    #define MAYBE_FAIL_WITH_ICU_ERROR(s) \
606        if (status != U_ZERO_ERROR) {\
607            ALOGE("Couldn't initialize ICU (" s "): %s (%s)", u_errorName(status), path.c_str()); \
608            abort(); \
609        }
610
611    // Open the file and get its length.
612    ScopedFd fd(open(path.c_str(), O_RDONLY));
613    if (fd.get() == -1) {
614        FAIL_WITH_STRERROR("open");
615    }
616    struct stat sb;
617    if (fstat(fd.get(), &sb) == -1) {
618        FAIL_WITH_STRERROR("stat");
619    }
620
621    // Map it.
622    void* data = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd.get(), 0);
623    if (data == MAP_FAILED) {
624        FAIL_WITH_STRERROR("mmap");
625    }
626
627    // Tell the kernel that accesses are likely to be random rather than sequential.
628    if (madvise(data, sb.st_size, MADV_RANDOM) == -1) {
629        FAIL_WITH_STRERROR("madvise(MADV_RANDOM)");
630    }
631
632    // Tell ICU to use our memory-mapped data.
633    UErrorCode status = U_ZERO_ERROR;
634    udata_setCommonData(data, &status);
635    MAYBE_FAIL_WITH_ICU_ERROR("udata_setCommonData");
636    // Tell ICU it can *only* use our memory-mapped data.
637    udata_setFileAccess(UDATA_NO_FILES, &status);
638    MAYBE_FAIL_WITH_ICU_ERROR("udata_setFileAccess");
639
640    // Failures to find the ICU data tend to be somewhat obscure because ICU loads its data on first
641    // use, which can be anywhere. Force initialization up front so we can report a nice clear error
642    // and bail.
643    u_init(&status);
644    MAYBE_FAIL_WITH_ICU_ERROR("u_init");
645    jniRegisterNativeMethods(env, "libcore/icu/ICU", gMethods, NELEM(gMethods));
646}
647