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