libcore_icu_ICU.cpp revision c5b1eb191102a20bc0626aea955aba417e337fbc 
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 "IcuUtilities.h"
20#include "JNIHelp.h"
21#include "JniConstants.h"
22#include "JniException.h"
23#include "ScopedFd.h"
24#include "ScopedJavaUnicodeString.h"
25#include "ScopedLocalRef.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/dtptngen.h"
36#include "unicode/gregocal.h"
37#include "unicode/locid.h"
38#include "unicode/numfmt.h"
39#include "unicode/strenum.h"
40#include "unicode/ubrk.h"
41#include "unicode/ucal.h"
42#include "unicode/uclean.h"
43#include "unicode/ucol.h"
44#include "unicode/ucurr.h"
45#include "unicode/udat.h"
46#include "unicode/uloc.h"
47#include "unicode/ulocdata.h"
48#include "unicode/ustring.h"
49#include "ureslocs.h"
50#include "valueOf.h"
51
52#include <errno.h>
53#include <fcntl.h>
54#include <stdlib.h>
55#include <string.h>
56#include <string>
57#include <sys/mman.h>
58#include <sys/stat.h>
59#include <sys/time.h>
60#include <sys/types.h>
61#include <time.h>
62#include <unistd.h>
63#include <vector>
64
65// TODO: put this in a header file and use it everywhere!
66// DISALLOW_COPY_AND_ASSIGN disallows the copy and operator= functions.
67// It goes in the private: declarations in a class.
68#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
69    TypeName(const TypeName&); \
70    void operator=(const TypeName&)
71
72class ScopedResourceBundle {
73 public:
74  ScopedResourceBundle(UResourceBundle* bundle) : bundle_(bundle) {
75  }
76
77  ~ScopedResourceBundle() {
78    if (bundle_ != NULL) {
79      ures_close(bundle_);
80    }
81  }
82
83  UResourceBundle* get() {
84    return bundle_;
85  }
86
87  bool hasKey(const char* key) {
88    UErrorCode status = U_ZERO_ERROR;
89    ures_getStringByKey(bundle_, key, NULL, &status);
90    return U_SUCCESS(status);
91  }
92
93 private:
94  UResourceBundle* bundle_;
95  DISALLOW_COPY_AND_ASSIGN(ScopedResourceBundle);
96};
97
98static jstring ICU_addLikelySubtags(JNIEnv* env, jclass, jstring javaLocale) {
99    UErrorCode status = U_ZERO_ERROR;
100    ScopedUtfChars localeID(env, javaLocale);
101    char maximizedLocaleID[ULOC_FULLNAME_CAPACITY];
102    uloc_addLikelySubtags(localeID.c_str(), maximizedLocaleID, sizeof(maximizedLocaleID), &status);
103    if (U_FAILURE(status)) {
104        return javaLocale;
105    }
106    return env->NewStringUTF(maximizedLocaleID);
107}
108
109static jstring ICU_getScript(JNIEnv* env, jclass, jstring javaLocale) {
110    UErrorCode status = U_ZERO_ERROR;
111    ScopedUtfChars localeID(env, javaLocale);
112    char script[ULOC_SCRIPT_CAPACITY];
113    uloc_getScript(localeID.c_str(), script, sizeof(script), &status);
114    if (U_FAILURE(status)) {
115        return NULL;
116    }
117    return env->NewStringUTF(script);
118}
119
120static jstring ICU_localeForLanguageTag(JNIEnv* env, jclass, jstring languageTag, jboolean strict) {
121    ScopedUtfChars languageTagChars(env, languageTag);
122
123    // Naively assume that in the average case, the size of
124    // the normalized language tag will be very nearly the same as the
125    // size of the input. This is generally true for language
126    // tags that are "simple" language-region-variant combinations
127    // that don't contain any grandfathered tags.
128    const size_t initialBufferSize = languageTagChars.size() + 32;
129    std::vector<char> buffer(initialBufferSize);
130    int32_t parsedLength = 0;
131
132    UErrorCode status = U_ZERO_ERROR;
133    while (true) {
134        const size_t outputLength = uloc_forLanguageTag(languageTagChars.c_str(),
135               &buffer[0], buffer.size(), &parsedLength, &status);
136        if (U_FAILURE(status)) {
137            return NULL;
138        }
139
140        // Assume that we've run out of buffer space when this happens. Double
141        // the buffer size and try again. This should happen very infrequently.
142        if (outputLength == buffer.size()) {
143            buffer.resize(buffer.size() << 1);
144        } else {
145            break;
146        }
147    }
148
149    if (parsedLength < 0) {
150        return NULL;
151    }
152
153    // By default, ICU will ignore all subtags starting at the first unparseable
154    // or invalid subtag. Our "strict" mode is specified to throw an error if
155    // that happens.
156    //
157    // NOTE: The cast is safe because parsedLength can never be negative thanks
158    // to the check above. ICU does not document any negative return values for
159    // that field, but check for it anyway.
160    if ((strict == JNI_TRUE) &&
161        (static_cast<uint32_t>(parsedLength) != languageTagChars.size())) {
162        return NULL;
163    }
164
165    return env->NewStringUTF(&buffer[0]);
166}
167
168static jstring ICU_languageTagForLocale(JNIEnv* env, jclass, jstring javaLocaleId) {
169    ScopedUtfChars localeID(env, javaLocaleId);
170
171    // The conversion from an ICU locale ID to a BCP 47 tag will shrink
172    // the size of the string unless there's an invalid language or a bad
173    // parse (which will result in an x-lvariant private use subtag at
174    // the end of the input).
175    const size_t initialBufferSize = localeID.size();
176    std::vector<char> buffer(initialBufferSize);
177
178    UErrorCode status = U_ZERO_ERROR;
179    while (true) {
180        const size_t outputLength = uloc_toLanguageTag(localeID.c_str(),
181                &buffer[0], buffer.size(), false /* strict */, &status);
182        if (U_FAILURE(status)) {
183            return NULL;
184        }
185
186        if (outputLength == buffer.size()) {
187            buffer.resize(buffer.size() << 1);
188        } else {
189            break;
190        }
191    }
192
193    return env->NewStringUTF(&buffer[0]);
194}
195
196static jint ICU_getCurrencyFractionDigits(JNIEnv* env, jclass, jstring javaCurrencyCode) {
197  ScopedJavaUnicodeString currencyCode(env, javaCurrencyCode);
198  if (!currencyCode.valid()) {
199    return 0;
200  }
201  UnicodeString icuCurrencyCode(currencyCode.unicodeString());
202  UErrorCode status = U_ZERO_ERROR;
203  return ucurr_getDefaultFractionDigits(icuCurrencyCode.getTerminatedBuffer(), &status);
204}
205
206// TODO: rewrite this with int32_t ucurr_forLocale(const char* locale, UChar* buff, int32_t buffCapacity, UErrorCode* ec)...
207static jstring ICU_getCurrencyCode(JNIEnv* env, jclass, jstring javaCountryCode) {
208    UErrorCode status = U_ZERO_ERROR;
209    ScopedResourceBundle supplData(ures_openDirect(U_ICUDATA_CURR, "supplementalData", &status));
210    if (U_FAILURE(status)) {
211        return NULL;
212    }
213
214    ScopedResourceBundle currencyMap(ures_getByKey(supplData.get(), "CurrencyMap", NULL, &status));
215    if (U_FAILURE(status)) {
216        return NULL;
217    }
218
219    ScopedUtfChars countryCode(env, javaCountryCode);
220    ScopedResourceBundle currency(ures_getByKey(currencyMap.get(), countryCode.c_str(), NULL, &status));
221    if (U_FAILURE(status)) {
222        return NULL;
223    }
224
225    ScopedResourceBundle currencyElem(ures_getByIndex(currency.get(), 0, NULL, &status));
226    if (U_FAILURE(status)) {
227        return env->NewStringUTF("XXX");
228    }
229
230    // Check if there's a 'to' date. If there is, the currency isn't used anymore.
231    ScopedResourceBundle currencyTo(ures_getByKey(currencyElem.get(), "to", NULL, &status));
232    if (!U_FAILURE(status)) {
233        return NULL;
234    }
235    // Ignore the failure to find a 'to' date.
236    status = U_ZERO_ERROR;
237
238    ScopedResourceBundle currencyId(ures_getByKey(currencyElem.get(), "id", NULL, &status));
239    if (U_FAILURE(status)) {
240        // No id defined for this country
241        return env->NewStringUTF("XXX");
242    }
243
244    int32_t charCount;
245    const jchar* chars = ures_getString(currencyId.get(), &charCount, &status);
246    return (charCount == 0) ? env->NewStringUTF("XXX") : env->NewString(chars, charCount);
247}
248
249static jstring getCurrencyName(JNIEnv* env, jstring javaLocaleName, jstring javaCurrencyCode, UCurrNameStyle nameStyle) {
250  ScopedUtfChars localeName(env, javaLocaleName);
251  if (localeName.c_str() == NULL) {
252    return NULL;
253  }
254  ScopedJavaUnicodeString currencyCode(env, javaCurrencyCode);
255  if (!currencyCode.valid()) {
256    return NULL;
257  }
258  UnicodeString icuCurrencyCode(currencyCode.unicodeString());
259  UErrorCode status = U_ZERO_ERROR;
260  UBool isChoiceFormat = false;
261  int32_t charCount;
262  const UChar* chars = ucurr_getName(icuCurrencyCode.getTerminatedBuffer(), localeName.c_str(),
263                                     nameStyle, &isChoiceFormat, &charCount, &status);
264  if (status == U_USING_DEFAULT_WARNING) {
265    if (nameStyle == UCURR_SYMBOL_NAME) {
266      // ICU doesn't distinguish between falling back to the root locale and meeting a genuinely
267      // unknown currency. The Currency class does.
268      if (!ucurr_isAvailable(icuCurrencyCode.getTerminatedBuffer(), U_DATE_MIN, U_DATE_MAX, &status)) {
269        return NULL;
270      }
271    }
272    if (nameStyle == UCURR_LONG_NAME) {
273      // ICU's default is English. We want the ISO 4217 currency code instead.
274      chars = icuCurrencyCode.getBuffer();
275      charCount = icuCurrencyCode.length();
276    }
277  }
278  return (charCount == 0) ? NULL : env->NewString(chars, charCount);
279}
280
281static jstring ICU_getCurrencyDisplayName(JNIEnv* env, jclass, jstring javaLocaleName, jstring javaCurrencyCode) {
282  return getCurrencyName(env, javaLocaleName, javaCurrencyCode, UCURR_LONG_NAME);
283}
284
285static jstring ICU_getCurrencySymbol(JNIEnv* env, jclass, jstring javaLocaleName, jstring javaCurrencyCode) {
286  return getCurrencyName(env, javaLocaleName, javaCurrencyCode, UCURR_SYMBOL_NAME);
287}
288
289static jstring ICU_getDisplayCountryNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
290    Locale loc = getLocale(env, locale);
291    Locale targetLoc = getLocale(env, targetLocale);
292    UnicodeString str;
293    targetLoc.getDisplayCountry(loc, str);
294    return env->NewString(str.getBuffer(), str.length());
295}
296
297static jstring ICU_getDisplayLanguageNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
298    Locale loc = getLocale(env, locale);
299    Locale targetLoc = getLocale(env, targetLocale);
300    UnicodeString str;
301    targetLoc.getDisplayLanguage(loc, str);
302    return env->NewString(str.getBuffer(), str.length());
303}
304
305static jstring ICU_getDisplayScriptNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
306    Locale loc = getLocale(env, locale);
307    Locale targetLoc = getLocale(env, targetLocale);
308    UnicodeString str;
309    targetLoc.getDisplayScript(loc, str);
310    return env->NewString(str.getBuffer(), str.length());
311}
312
313static jstring ICU_getDisplayVariantNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
314    Locale loc = getLocale(env, locale);
315    Locale targetLoc = getLocale(env, targetLocale);
316    UnicodeString str;
317    targetLoc.getDisplayVariant(loc, str);
318    return env->NewString(str.getBuffer(), str.length());
319}
320
321static jstring ICU_getISO3CountryNative(JNIEnv* env, jclass, jstring locale) {
322    Locale loc = getLocale(env, locale);
323    return env->NewStringUTF(loc.getISO3Country());
324}
325
326static jstring ICU_getISO3LanguageNative(JNIEnv* env, jclass, jstring locale) {
327    Locale loc = getLocale(env, locale);
328    return env->NewStringUTF(loc.getISO3Language());
329}
330
331static jobjectArray ICU_getISOCountriesNative(JNIEnv* env, jclass) {
332    return toStringArray(env, Locale::getISOCountries());
333}
334
335static jobjectArray ICU_getISOLanguagesNative(JNIEnv* env, jclass) {
336    return toStringArray(env, Locale::getISOLanguages());
337}
338
339static jobjectArray ICU_getAvailableLocalesNative(JNIEnv* env, jclass) {
340    return toStringArray(env, uloc_countAvailable, uloc_getAvailable);
341}
342
343static jobjectArray ICU_getAvailableBreakIteratorLocalesNative(JNIEnv* env, jclass) {
344    return toStringArray(env, ubrk_countAvailable, ubrk_getAvailable);
345}
346
347static jobjectArray ICU_getAvailableCalendarLocalesNative(JNIEnv* env, jclass) {
348    return toStringArray(env, ucal_countAvailable, ucal_getAvailable);
349}
350
351static jobjectArray ICU_getAvailableCollatorLocalesNative(JNIEnv* env, jclass) {
352    return toStringArray(env, ucol_countAvailable, ucol_getAvailable);
353}
354
355static jobjectArray ICU_getAvailableDateFormatLocalesNative(JNIEnv* env, jclass) {
356    return toStringArray(env, udat_countAvailable, udat_getAvailable);
357}
358
359static jobjectArray ICU_getAvailableNumberFormatLocalesNative(JNIEnv* env, jclass) {
360    return toStringArray(env, unum_countAvailable, unum_getAvailable);
361}
362
363static 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
369static 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
375static 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
380static void setStringArrayField(JNIEnv* env, jobject obj, const char* fieldName, const UnicodeString* valueArray, int32_t size) {
381    ScopedLocalRef<jobjectArray> result(env, env->NewObjectArray(size, JniConstants::stringClass, NULL));
382    for (int32_t i = 0; i < size ; i++) {
383        ScopedLocalRef<jstring> s(env, env->NewString(valueArray[i].getBuffer(),valueArray[i].length()));
384        if (env->ExceptionCheck()) {
385            return;
386        }
387        env->SetObjectArrayElement(result.get(), i, s.get());
388        if (env->ExceptionCheck()) {
389            return;
390        }
391    }
392    setStringArrayField(env, obj, fieldName, result.get());
393}
394
395static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, UResourceBundle* bundle, int index) {
396  UErrorCode status = U_ZERO_ERROR;
397  int charCount;
398  const UChar* chars = ures_getStringByIndex(bundle, index, &charCount, &status);
399  if (U_SUCCESS(status)) {
400    setStringField(env, obj, fieldName, env->NewString(chars, charCount));
401  } else {
402    ALOGE("Error setting String field %s from ICU resource (index %d): %s", fieldName, index, u_errorName(status));
403  }
404}
405
406static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, UResourceBundle* bundle, const char* key) {
407  UErrorCode status = U_ZERO_ERROR;
408  int charCount;
409  const UChar* chars = ures_getStringByKey(bundle, key, &charCount, &status);
410  if (U_SUCCESS(status)) {
411    setStringField(env, obj, fieldName, env->NewString(chars, charCount));
412  } else {
413    ALOGE("Error setting String field %s from ICU resource (key %s): %s", fieldName, key, u_errorName(status));
414  }
415}
416
417static void setCharField(JNIEnv* env, jobject obj, const char* fieldName, const UnicodeString& value) {
418    if (value.length() == 0) {
419        return;
420    }
421    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "C");
422    env->SetCharField(obj, fid, value.charAt(0));
423}
424
425static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, const UnicodeString& value) {
426    const UChar* chars = value.getBuffer();
427    setStringField(env, obj, fieldName, env->NewString(chars, value.length()));
428}
429
430static void setNumberPatterns(JNIEnv* env, jobject obj, Locale& locale) {
431    UErrorCode status = U_ZERO_ERROR;
432
433    UnicodeString pattern;
434    UniquePtr<DecimalFormat> fmt(static_cast<DecimalFormat*>(NumberFormat::createInstance(locale, UNUM_CURRENCY, status)));
435    pattern = fmt->toPattern(pattern.remove());
436    setStringField(env, obj, "currencyPattern", pattern);
437
438    fmt.reset(static_cast<DecimalFormat*>(NumberFormat::createInstance(locale, UNUM_DECIMAL, status)));
439    pattern = fmt->toPattern(pattern.remove());
440    setStringField(env, obj, "numberPattern", pattern);
441
442    fmt.reset(static_cast<DecimalFormat*>(NumberFormat::createInstance(locale, UNUM_PERCENT, status)));
443    pattern = fmt->toPattern(pattern.remove());
444    setStringField(env, obj, "percentPattern", pattern);
445}
446
447static void setDecimalFormatSymbolsData(JNIEnv* env, jobject obj, Locale& locale) {
448    UErrorCode status = U_ZERO_ERROR;
449    DecimalFormatSymbols dfs(locale, status);
450
451    setCharField(env, obj, "decimalSeparator", dfs.getSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol));
452    setCharField(env, obj, "groupingSeparator", dfs.getSymbol(DecimalFormatSymbols::kGroupingSeparatorSymbol));
453    setCharField(env, obj, "patternSeparator", dfs.getSymbol(DecimalFormatSymbols::kPatternSeparatorSymbol));
454    setCharField(env, obj, "percent", dfs.getSymbol(DecimalFormatSymbols::kPercentSymbol));
455    setCharField(env, obj, "perMill", dfs.getSymbol(DecimalFormatSymbols::kPerMillSymbol));
456    setCharField(env, obj, "monetarySeparator", dfs.getSymbol(DecimalFormatSymbols::kMonetarySeparatorSymbol));
457    setCharField(env, obj, "minusSign", dfs.getSymbol(DecimalFormatSymbols:: kMinusSignSymbol));
458    setStringField(env, obj, "exponentSeparator", dfs.getSymbol(DecimalFormatSymbols::kExponentialSymbol));
459    setStringField(env, obj, "infinity", dfs.getSymbol(DecimalFormatSymbols::kInfinitySymbol));
460    setStringField(env, obj, "NaN", dfs.getSymbol(DecimalFormatSymbols::kNaNSymbol));
461    setCharField(env, obj, "zeroDigit", dfs.getSymbol(DecimalFormatSymbols::kZeroDigitSymbol));
462}
463
464
465// Iterates up through the locale hierarchy. So "en_US" would return "en_US", "en", "".
466class LocaleNameIterator {
467 public:
468  LocaleNameIterator(const char* locale_name, UErrorCode& status) : status_(status), has_next_(true) {
469    strcpy(locale_name_, locale_name);
470    locale_name_length_ = strlen(locale_name_);
471  }
472
473  const char* Get() {
474      return locale_name_;
475  }
476
477  bool HasNext() {
478    return has_next_;
479  }
480
481  void Up() {
482    if (locale_name_length_ == 0) {
483      has_next_ = false;
484    } else {
485      locale_name_length_ = uloc_getParent(locale_name_, locale_name_, sizeof(locale_name_), &status_);
486    }
487  }
488
489 private:
490  UErrorCode& status_;
491  bool has_next_;
492  char locale_name_[ULOC_FULLNAME_CAPACITY];
493  int32_t locale_name_length_;
494
495  DISALLOW_COPY_AND_ASSIGN(LocaleNameIterator);
496};
497
498static bool getDateTimePatterns(JNIEnv* env, jobject localeData, const char* locale_name) {
499  UErrorCode status = U_ZERO_ERROR;
500  ScopedResourceBundle root(ures_open(NULL, locale_name, &status));
501  if (U_FAILURE(status)) {
502    return false;
503  }
504  ScopedResourceBundle calendar(ures_getByKey(root.get(), "calendar", NULL, &status));
505  if (U_FAILURE(status)) {
506    return false;
507  }
508  ScopedResourceBundle gregorian(ures_getByKey(calendar.get(), "gregorian", NULL, &status));
509  if (U_FAILURE(status)) {
510    return false;
511  }
512  ScopedResourceBundle dateTimePatterns(ures_getByKey(gregorian.get(), "DateTimePatterns", NULL, &status));
513  if (U_FAILURE(status)) {
514    return false;
515  }
516  setStringField(env, localeData, "fullTimeFormat", dateTimePatterns.get(), 0);
517  setStringField(env, localeData, "longTimeFormat", dateTimePatterns.get(), 1);
518  setStringField(env, localeData, "mediumTimeFormat", dateTimePatterns.get(), 2);
519  setStringField(env, localeData, "shortTimeFormat", dateTimePatterns.get(), 3);
520  setStringField(env, localeData, "fullDateFormat", dateTimePatterns.get(), 4);
521  setStringField(env, localeData, "longDateFormat", dateTimePatterns.get(), 5);
522  setStringField(env, localeData, "mediumDateFormat", dateTimePatterns.get(), 6);
523  setStringField(env, localeData, "shortDateFormat", dateTimePatterns.get(), 7);
524  return true;
525}
526
527static bool getYesterdayTodayAndTomorrow(JNIEnv* env, jobject localeData, const char* locale_name) {
528  UErrorCode status = U_ZERO_ERROR;
529  ScopedResourceBundle root(ures_open(NULL, locale_name, &status));
530  if (U_FAILURE(status)) {
531    return false;
532  }
533  ScopedResourceBundle fields(ures_getByKey(root.get(), "fields", NULL, &status));
534  if (U_FAILURE(status)) {
535    return false;
536  }
537  ScopedResourceBundle day(ures_getByKey(fields.get(), "day", NULL, &status));
538  if (U_FAILURE(status)) {
539    return false;
540  }
541  ScopedResourceBundle relative(ures_getByKey(day.get(), "relative", NULL, &status));
542  if (U_FAILURE(status)) {
543    return false;
544  }
545  // bn_BD only has a "-2" entry.
546  if (relative.hasKey("-1") && relative.hasKey("0") && relative.hasKey("1")) {
547    setStringField(env, localeData, "yesterday", relative.get(), "-1");
548    setStringField(env, localeData, "today", relative.get(), "0");
549    setStringField(env, localeData, "tomorrow", relative.get(), "1");
550    return true;
551  }
552  return false;
553}
554
555static jboolean ICU_initLocaleDataNative(JNIEnv* env, jclass, jstring javaLocaleName, jobject localeData) {
556    ScopedUtfChars localeName(env, javaLocaleName);
557    if (localeName.c_str() == NULL) {
558        return JNI_FALSE;
559    }
560    if (localeName.size() >= ULOC_FULLNAME_CAPACITY) {
561        return JNI_FALSE; // ICU has a fixed-length limit.
562    }
563
564    // Get the DateTimePatterns.
565    UErrorCode status = U_ZERO_ERROR;
566    bool foundDateTimePatterns = false;
567    for (LocaleNameIterator it(localeName.c_str(), status); it.HasNext(); it.Up()) {
568      if (getDateTimePatterns(env, localeData, it.Get())) {
569          foundDateTimePatterns = true;
570          break;
571      }
572    }
573    if (!foundDateTimePatterns) {
574        ALOGE("Couldn't find ICU DateTimePatterns for %s", localeName.c_str());
575        return JNI_FALSE;
576    }
577
578    // Get the "Yesterday", "Today", and "Tomorrow" strings.
579    bool foundYesterdayTodayAndTomorrow = false;
580    for (LocaleNameIterator it(localeName.c_str(), status); it.HasNext(); it.Up()) {
581      if (getYesterdayTodayAndTomorrow(env, localeData, it.Get())) {
582        foundYesterdayTodayAndTomorrow = true;
583        break;
584      }
585    }
586    if (!foundYesterdayTodayAndTomorrow) {
587      ALOGE("Couldn't find ICU yesterday/today/tomorrow for %s", localeName.c_str());
588      return JNI_FALSE;
589    }
590
591    status = U_ZERO_ERROR;
592    Locale locale = getLocale(env, javaLocaleName);
593    UniquePtr<Calendar> cal(Calendar::createInstance(locale, status));
594    if (U_FAILURE(status)) {
595        return JNI_FALSE;
596    }
597
598    setIntegerField(env, localeData, "firstDayOfWeek", cal->getFirstDayOfWeek());
599    setIntegerField(env, localeData, "minimalDaysInFirstWeek", cal->getMinimalDaysInFirstWeek());
600
601    // Get DateFormatSymbols.
602    status = U_ZERO_ERROR;
603    DateFormatSymbols dateFormatSym(locale, status);
604    if (U_FAILURE(status)) {
605        return JNI_FALSE;
606    }
607
608    // Get AM/PM and BC/AD.
609    int32_t count = 0;
610    const UnicodeString* amPmStrs = dateFormatSym.getAmPmStrings(count);
611    setStringArrayField(env, localeData, "amPm", amPmStrs, count);
612    const UnicodeString* erasStrs = dateFormatSym.getEras(count);
613    setStringArrayField(env, localeData, "eras", erasStrs, count);
614
615    const UnicodeString* longMonthNames =
616       dateFormatSym.getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
617    setStringArrayField(env, localeData, "longMonthNames", longMonthNames, count);
618    const UnicodeString* shortMonthNames =
619        dateFormatSym.getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
620    setStringArrayField(env, localeData, "shortMonthNames", shortMonthNames, count);
621    const UnicodeString* tinyMonthNames =
622        dateFormatSym.getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
623    setStringArrayField(env, localeData, "tinyMonthNames", tinyMonthNames, count);
624    const UnicodeString* longWeekdayNames =
625        dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
626    setStringArrayField(env, localeData, "longWeekdayNames", longWeekdayNames, count);
627    const UnicodeString* shortWeekdayNames =
628        dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
629    setStringArrayField(env, localeData, "shortWeekdayNames", shortWeekdayNames, count);
630    const UnicodeString* tinyWeekdayNames =
631        dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
632    setStringArrayField(env, localeData, "tinyWeekdayNames", tinyWeekdayNames, count);
633
634    const UnicodeString* longStandAloneMonthNames =
635        dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
636    setStringArrayField(env, localeData, "longStandAloneMonthNames", longStandAloneMonthNames, count);
637    const UnicodeString* shortStandAloneMonthNames =
638        dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
639    setStringArrayField(env, localeData, "shortStandAloneMonthNames", shortStandAloneMonthNames, count);
640    const UnicodeString* tinyStandAloneMonthNames =
641        dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
642    setStringArrayField(env, localeData, "tinyStandAloneMonthNames", tinyStandAloneMonthNames, count);
643    const UnicodeString* longStandAloneWeekdayNames =
644        dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
645    setStringArrayField(env, localeData, "longStandAloneWeekdayNames", longStandAloneWeekdayNames, count);
646    const UnicodeString* shortStandAloneWeekdayNames =
647        dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
648    setStringArrayField(env, localeData, "shortStandAloneWeekdayNames", shortStandAloneWeekdayNames, count);
649    const UnicodeString* tinyStandAloneWeekdayNames =
650        dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
651    setStringArrayField(env, localeData, "tinyStandAloneWeekdayNames", tinyStandAloneWeekdayNames, count);
652
653    status = U_ZERO_ERROR;
654
655    // For numberPatterns and symbols.
656    setNumberPatterns(env, localeData, locale);
657    setDecimalFormatSymbolsData(env, localeData, locale);
658
659    jstring countryCode = env->NewStringUTF(Locale::createFromName(localeName.c_str()).getCountry());
660    jstring internationalCurrencySymbol = ICU_getCurrencyCode(env, NULL, countryCode);
661    env->DeleteLocalRef(countryCode);
662    countryCode = NULL;
663
664    jstring currencySymbol = NULL;
665    if (internationalCurrencySymbol != NULL) {
666        currencySymbol = ICU_getCurrencySymbol(env, NULL, javaLocaleName, internationalCurrencySymbol);
667    } else {
668        internationalCurrencySymbol = env->NewStringUTF("XXX");
669    }
670    if (currencySymbol == NULL) {
671        // This is the UTF-8 encoding of U+00A4 (CURRENCY SIGN).
672        currencySymbol = env->NewStringUTF("\xc2\xa4");
673    }
674    setStringField(env, localeData, "currencySymbol", currencySymbol);
675    setStringField(env, localeData, "internationalCurrencySymbol", internationalCurrencySymbol);
676
677    return JNI_TRUE;
678}
679
680static jstring ICU_toLowerCase(JNIEnv* env, jclass, jstring javaString, jstring localeName) {
681  ScopedJavaUnicodeString scopedString(env, javaString);
682  if (!scopedString.valid()) {
683    return NULL;
684  }
685  UnicodeString& s(scopedString.unicodeString());
686  UnicodeString original(s);
687  s.toLower(getLocale(env, localeName));
688  return s == original ? javaString : env->NewString(s.getBuffer(), s.length());
689}
690
691static jstring ICU_toUpperCase(JNIEnv* env, jclass, jstring javaString, jstring localeName) {
692  ScopedJavaUnicodeString scopedString(env, javaString);
693  if (!scopedString.valid()) {
694    return NULL;
695  }
696  UnicodeString& s(scopedString.unicodeString());
697  UnicodeString original(s);
698  s.toUpper(getLocale(env, localeName));
699  return s == original ? javaString : env->NewString(s.getBuffer(), s.length());
700}
701
702static jstring versionString(JNIEnv* env, const UVersionInfo& version) {
703    char versionString[U_MAX_VERSION_STRING_LENGTH];
704    u_versionToString(const_cast<UVersionInfo&>(version), &versionString[0]);
705    return env->NewStringUTF(versionString);
706}
707
708static jstring ICU_getCldrVersion(JNIEnv* env, jclass) {
709  UErrorCode status = U_ZERO_ERROR;
710  UVersionInfo cldrVersion;
711  ulocdata_getCLDRVersion(cldrVersion, &status);
712  return versionString(env, cldrVersion);
713}
714
715static jstring ICU_getIcuVersion(JNIEnv* env, jclass) {
716    UVersionInfo icuVersion;
717    u_getVersion(icuVersion);
718    return versionString(env, icuVersion);
719}
720
721static jstring ICU_getUnicodeVersion(JNIEnv* env, jclass) {
722    UVersionInfo unicodeVersion;
723    u_getUnicodeVersion(unicodeVersion);
724    return versionString(env, unicodeVersion);
725}
726
727static jobject ICU_getAvailableCurrencyCodes(JNIEnv* env, jclass) {
728  UErrorCode status = U_ZERO_ERROR;
729  UStringEnumeration e(ucurr_openISOCurrencies(UCURR_COMMON|UCURR_NON_DEPRECATED, &status));
730  return fromStringEnumeration(env, status, "ucurr_openISOCurrencies", &e);
731}
732
733static jstring ICU_getBestDateTimePatternNative(JNIEnv* env, jclass, jstring javaSkeleton, jstring javaLocaleName) {
734  Locale locale = getLocale(env, javaLocaleName);
735  UErrorCode status = U_ZERO_ERROR;
736  UniquePtr<DateTimePatternGenerator> generator(DateTimePatternGenerator::createInstance(locale, status));
737  if (maybeThrowIcuException(env, "DateTimePatternGenerator::createInstance", status)) {
738    return NULL;
739  }
740
741  ScopedJavaUnicodeString skeletonHolder(env, javaSkeleton);
742  if (!skeletonHolder.valid()) {
743    return NULL;
744  }
745  UnicodeString result(generator->getBestPattern(skeletonHolder.unicodeString(), status));
746  if (maybeThrowIcuException(env, "DateTimePatternGenerator::getBestPattern", status)) {
747    return NULL;
748  }
749
750  return env->NewString(result.getBuffer(), result.length());
751}
752
753static JNINativeMethod gMethods[] = {
754    NATIVE_METHOD(ICU, addLikelySubtags, "(Ljava/lang/String;)Ljava/lang/String;"),
755    NATIVE_METHOD(ICU, getAvailableBreakIteratorLocalesNative, "()[Ljava/lang/String;"),
756    NATIVE_METHOD(ICU, getAvailableCalendarLocalesNative, "()[Ljava/lang/String;"),
757    NATIVE_METHOD(ICU, getAvailableCollatorLocalesNative, "()[Ljava/lang/String;"),
758    NATIVE_METHOD(ICU, getAvailableCurrencyCodes, "()[Ljava/lang/String;"),
759    NATIVE_METHOD(ICU, getAvailableDateFormatLocalesNative, "()[Ljava/lang/String;"),
760    NATIVE_METHOD(ICU, getAvailableLocalesNative, "()[Ljava/lang/String;"),
761    NATIVE_METHOD(ICU, getAvailableNumberFormatLocalesNative, "()[Ljava/lang/String;"),
762    NATIVE_METHOD(ICU, getBestDateTimePatternNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
763    NATIVE_METHOD(ICU, getCldrVersion, "()Ljava/lang/String;"),
764    NATIVE_METHOD(ICU, getCurrencyCode, "(Ljava/lang/String;)Ljava/lang/String;"),
765    NATIVE_METHOD(ICU, getCurrencyDisplayName, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
766    NATIVE_METHOD(ICU, getCurrencyFractionDigits, "(Ljava/lang/String;)I"),
767    NATIVE_METHOD(ICU, getCurrencySymbol, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
768    NATIVE_METHOD(ICU, getDisplayCountryNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
769    NATIVE_METHOD(ICU, getDisplayLanguageNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
770    NATIVE_METHOD(ICU, getDisplayScriptNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
771    NATIVE_METHOD(ICU, getDisplayVariantNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
772    NATIVE_METHOD(ICU, getISO3CountryNative, "(Ljava/lang/String;)Ljava/lang/String;"),
773    NATIVE_METHOD(ICU, getISO3LanguageNative, "(Ljava/lang/String;)Ljava/lang/String;"),
774    NATIVE_METHOD(ICU, getISOCountriesNative, "()[Ljava/lang/String;"),
775    NATIVE_METHOD(ICU, getISOLanguagesNative, "()[Ljava/lang/String;"),
776    NATIVE_METHOD(ICU, getIcuVersion, "()Ljava/lang/String;"),
777    NATIVE_METHOD(ICU, getScript, "(Ljava/lang/String;)Ljava/lang/String;"),
778    NATIVE_METHOD(ICU, getUnicodeVersion, "()Ljava/lang/String;"),
779    NATIVE_METHOD(ICU, languageTagForLocale, "(Ljava/lang/String;)Ljava/lang/String;"),
780    NATIVE_METHOD(ICU, localeForLanguageTag, "(Ljava/lang/String;Z)Ljava/lang/String;"),
781    NATIVE_METHOD(ICU, initLocaleDataNative, "(Ljava/lang/String;Llibcore/icu/LocaleData;)Z"),
782    NATIVE_METHOD(ICU, toLowerCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
783    NATIVE_METHOD(ICU, toUpperCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
784};
785void register_libcore_icu_ICU(JNIEnv* env) {
786    std::string path;
787    path = u_getDataDirectory();
788    path += "/";
789    path += U_ICUDATA_NAME;
790    path += ".dat";
791
792    #define FAIL_WITH_STRERROR(s) \
793        ALOGE("Couldn't " s " '%s': %s", path.c_str(), strerror(errno)); \
794        abort();
795    #define MAYBE_FAIL_WITH_ICU_ERROR(s) \
796        if (status != U_ZERO_ERROR) {\
797            ALOGE("Couldn't initialize ICU (" s "): %s (%s)", u_errorName(status), path.c_str()); \
798            abort(); \
799        }
800
801    // Open the file and get its length.
802    ScopedFd fd(open(path.c_str(), O_RDONLY));
803    if (fd.get() == -1) {
804        FAIL_WITH_STRERROR("open");
805    }
806    struct stat sb;
807    if (fstat(fd.get(), &sb) == -1) {
808        FAIL_WITH_STRERROR("stat");
809    }
810
811    // Map it.
812    void* data = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd.get(), 0);
813    if (data == MAP_FAILED) {
814        FAIL_WITH_STRERROR("mmap");
815    }
816
817    // Tell the kernel that accesses are likely to be random rather than sequential.
818    if (madvise(data, sb.st_size, MADV_RANDOM) == -1) {
819        FAIL_WITH_STRERROR("madvise(MADV_RANDOM)");
820    }
821
822    // Tell ICU to use our memory-mapped data.
823    UErrorCode status = U_ZERO_ERROR;
824    udata_setCommonData(data, &status);
825    MAYBE_FAIL_WITH_ICU_ERROR("udata_setCommonData");
826    // Tell ICU it can *only* use our memory-mapped data.
827    udata_setFileAccess(UDATA_NO_FILES, &status);
828    MAYBE_FAIL_WITH_ICU_ERROR("udata_setFileAccess");
829
830    // Failures to find the ICU data tend to be somewhat obscure because ICU loads its data on first
831    // use, which can be anywhere. Force initialization up front so we can report a nice clear error
832    // and bail.
833    u_init(&status);
834    MAYBE_FAIL_WITH_ICU_ERROR("u_init");
835    jniRegisterNativeMethods(env, "libcore/icu/ICU", gMethods, NELEM(gMethods));
836}
837