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