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 "ScopedIcuLocale.h"
25#include "ScopedJavaUnicodeString.h"
26#include "ScopedLocalRef.h"
27#include "ScopedUtfChars.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/timezone.h"
42#include "unicode/ubrk.h"
43#include "unicode/ucal.h"
44#include "unicode/uclean.h"
45#include "unicode/ucol.h"
46#include "unicode/ucurr.h"
47#include "unicode/udat.h"
48#include "unicode/uloc.h"
49#include "unicode/ulocdata.h"
50#include "unicode/ustring.h"
51#include "ureslocs.h"
52#include "valueOf.h"
53
54#include <errno.h>
55#include <fcntl.h>
56#include <stdlib.h>
57#include <string.h>
58#include <string>
59#include <sys/mman.h>
60#include <sys/stat.h>
61#include <sys/time.h>
62#include <sys/types.h>
63#include <time.h>
64#include <unistd.h>
65#include <memory>
66#include <vector>
67
68class ScopedResourceBundle {
69 public:
70  ScopedResourceBundle(UResourceBundle* bundle) : bundle_(bundle) {
71  }
72
73  ~ScopedResourceBundle() {
74    if (bundle_ != NULL) {
75      ures_close(bundle_);
76    }
77  }
78
79  UResourceBundle* get() {
80    return bundle_;
81  }
82
83  bool hasKey(const char* key) {
84    UErrorCode status = U_ZERO_ERROR;
85    ures_getStringByKey(bundle_, key, NULL, &status);
86    return U_SUCCESS(status);
87  }
88
89 private:
90  UResourceBundle* bundle_;
91  DISALLOW_COPY_AND_ASSIGN(ScopedResourceBundle);
92};
93
94static jstring ICU_addLikelySubtags(JNIEnv* env, jclass, jstring javaLocaleName) {
95    UErrorCode status = U_ZERO_ERROR;
96    ScopedUtfChars localeID(env, javaLocaleName);
97    char maximizedLocaleID[ULOC_FULLNAME_CAPACITY];
98    uloc_addLikelySubtags(localeID.c_str(), maximizedLocaleID, sizeof(maximizedLocaleID), &status);
99    if (U_FAILURE(status)) {
100        return javaLocaleName;
101    }
102    return env->NewStringUTF(maximizedLocaleID);
103}
104
105static jstring ICU_getScript(JNIEnv* env, jclass, jstring javaLocaleName) {
106  ScopedIcuLocale icuLocale(env, javaLocaleName);
107  if (!icuLocale.valid()) {
108    return NULL;
109  }
110  return env->NewStringUTF(icuLocale.locale().getScript());
111}
112
113static jint ICU_getCurrencyFractionDigits(JNIEnv* env, jclass, jstring javaCurrencyCode) {
114  ScopedJavaUnicodeString currencyCode(env, javaCurrencyCode);
115  if (!currencyCode.valid()) {
116    return 0;
117  }
118  icu::UnicodeString icuCurrencyCode(currencyCode.unicodeString());
119  UErrorCode status = U_ZERO_ERROR;
120  return ucurr_getDefaultFractionDigits(icuCurrencyCode.getTerminatedBuffer(), &status);
121}
122
123static jint ICU_getCurrencyNumericCode(JNIEnv* env, jclass, jstring javaCurrencyCode) {
124  ScopedJavaUnicodeString currencyCode(env, javaCurrencyCode);
125  if (!currencyCode.valid()) {
126    return 0;
127  }
128  icu::UnicodeString icuCurrencyCode(currencyCode.unicodeString());
129  return ucurr_getNumericCode(icuCurrencyCode.getTerminatedBuffer());
130}
131
132// TODO: rewrite this with int32_t ucurr_forLocale(const char* locale, UChar* buff, int32_t buffCapacity, UErrorCode* ec)...
133static jstring ICU_getCurrencyCode(JNIEnv* env, jclass, jstring javaCountryCode) {
134    UErrorCode status = U_ZERO_ERROR;
135    ScopedResourceBundle supplData(ures_openDirect(U_ICUDATA_CURR, "supplementalData", &status));
136    if (U_FAILURE(status)) {
137        return NULL;
138    }
139
140    ScopedResourceBundle currencyMap(ures_getByKey(supplData.get(), "CurrencyMap", NULL, &status));
141    if (U_FAILURE(status)) {
142        return NULL;
143    }
144
145    ScopedUtfChars countryCode(env, javaCountryCode);
146    ScopedResourceBundle currency(ures_getByKey(currencyMap.get(), countryCode.c_str(), NULL, &status));
147    if (U_FAILURE(status)) {
148        return NULL;
149    }
150
151    ScopedResourceBundle currencyElem(ures_getByIndex(currency.get(), 0, NULL, &status));
152    if (U_FAILURE(status)) {
153        return env->NewStringUTF("XXX");
154    }
155
156    // Check if there's a 'to' date. If there is, the currency isn't used anymore.
157    ScopedResourceBundle currencyTo(ures_getByKey(currencyElem.get(), "to", NULL, &status));
158    if (!U_FAILURE(status)) {
159        return NULL;
160    }
161    // Ignore the failure to find a 'to' date.
162    status = U_ZERO_ERROR;
163
164    ScopedResourceBundle currencyId(ures_getByKey(currencyElem.get(), "id", NULL, &status));
165    if (U_FAILURE(status)) {
166        // No id defined for this country
167        return env->NewStringUTF("XXX");
168    }
169
170    int32_t charCount;
171    const jchar* chars = ures_getString(currencyId.get(), &charCount, &status);
172    return (charCount == 0) ? env->NewStringUTF("XXX") : env->NewString(chars, charCount);
173}
174
175static jstring getCurrencyName(JNIEnv* env, jstring javaLanguageTag, jstring javaCurrencyCode, UCurrNameStyle nameStyle) {
176  ScopedUtfChars languageTag(env, javaLanguageTag);
177  if (languageTag.c_str() == NULL) {
178    return NULL;
179  }
180  ScopedJavaUnicodeString currencyCode(env, javaCurrencyCode);
181  if (!currencyCode.valid()) {
182    return NULL;
183  }
184  icu::UnicodeString icuCurrencyCode(currencyCode.unicodeString());
185  UErrorCode status = U_ZERO_ERROR;
186  UBool isChoiceFormat = false;
187  int32_t charCount;
188  const UChar* chars = ucurr_getName(icuCurrencyCode.getTerminatedBuffer(), languageTag.c_str(),
189                                     nameStyle, &isChoiceFormat, &charCount, &status);
190  if (status == U_USING_DEFAULT_WARNING) {
191    if (nameStyle == UCURR_SYMBOL_NAME) {
192      // ICU doesn't distinguish between falling back to the root locale and meeting a genuinely
193      // unknown currency. The Currency class does.
194      if (!ucurr_isAvailable(icuCurrencyCode.getTerminatedBuffer(), U_DATE_MIN, U_DATE_MAX, &status)) {
195        return NULL;
196      }
197    }
198    if (nameStyle == UCURR_LONG_NAME) {
199      // ICU's default is English. We want the ISO 4217 currency code instead.
200      chars = icuCurrencyCode.getBuffer();
201      charCount = icuCurrencyCode.length();
202    }
203  }
204  return (charCount == 0) ? NULL : env->NewString(chars, charCount);
205}
206
207static jstring ICU_getCurrencyDisplayName(JNIEnv* env, jclass, jstring javaLanguageTag, jstring javaCurrencyCode) {
208  return getCurrencyName(env, javaLanguageTag, javaCurrencyCode, UCURR_LONG_NAME);
209}
210
211static jstring ICU_getCurrencySymbol(JNIEnv* env, jclass, jstring javaLanguageTag, jstring javaCurrencyCode) {
212  return getCurrencyName(env, javaLanguageTag, javaCurrencyCode, UCURR_SYMBOL_NAME);
213}
214
215static jstring ICU_getDisplayCountryNative(JNIEnv* env, jclass, jstring javaTargetLanguageTag, jstring javaLanguageTag) {
216  ScopedIcuLocale icuLocale(env, javaLanguageTag);
217  if (!icuLocale.valid()) {
218    return NULL;
219  }
220  ScopedIcuLocale icuTargetLocale(env, javaTargetLanguageTag);
221  if (!icuTargetLocale.valid()) {
222    return NULL;
223  }
224
225  icu::UnicodeString str;
226  icuTargetLocale.locale().getDisplayCountry(icuLocale.locale(), str);
227  return env->NewString(str.getBuffer(), str.length());
228}
229
230static jstring ICU_getDisplayLanguageNative(JNIEnv* env, jclass, jstring javaTargetLanguageTag, jstring javaLanguageTag) {
231  ScopedIcuLocale icuLocale(env, javaLanguageTag);
232  if (!icuLocale.valid()) {
233    return NULL;
234  }
235  ScopedIcuLocale icuTargetLocale(env, javaTargetLanguageTag);
236  if (!icuTargetLocale.valid()) {
237    return NULL;
238  }
239
240  icu::UnicodeString str;
241  icuTargetLocale.locale().getDisplayLanguage(icuLocale.locale(), str);
242  return env->NewString(str.getBuffer(), str.length());
243}
244
245static jstring ICU_getDisplayScriptNative(JNIEnv* env, jclass, jstring javaTargetLanguageTag, jstring javaLanguageTag) {
246  ScopedIcuLocale icuLocale(env, javaLanguageTag);
247  if (!icuLocale.valid()) {
248    return NULL;
249  }
250  ScopedIcuLocale icuTargetLocale(env, javaTargetLanguageTag);
251  if (!icuTargetLocale.valid()) {
252    return NULL;
253  }
254
255  icu::UnicodeString str;
256  icuTargetLocale.locale().getDisplayScript(icuLocale.locale(), str);
257  return env->NewString(str.getBuffer(), str.length());
258}
259
260static jstring ICU_getDisplayVariantNative(JNIEnv* env, jclass, jstring javaTargetLanguageTag, jstring javaLanguageTag) {
261  ScopedIcuLocale icuLocale(env, javaLanguageTag);
262  if (!icuLocale.valid()) {
263    return NULL;
264  }
265  ScopedIcuLocale icuTargetLocale(env, javaTargetLanguageTag);
266  if (!icuTargetLocale.valid()) {
267    return NULL;
268  }
269
270  icu::UnicodeString str;
271  icuTargetLocale.locale().getDisplayVariant(icuLocale.locale(), str);
272  return env->NewString(str.getBuffer(), str.length());
273}
274
275static jstring ICU_getISO3Country(JNIEnv* env, jclass, jstring javaLanguageTag) {
276  ScopedIcuLocale icuLocale(env, javaLanguageTag);
277  if (!icuLocale.valid()) {
278    return NULL;
279  }
280  return env->NewStringUTF(icuLocale.locale().getISO3Country());
281}
282
283static jstring ICU_getISO3Language(JNIEnv* env, jclass, jstring javaLanguageTag) {
284  ScopedIcuLocale icuLocale(env, javaLanguageTag);
285  if (!icuLocale.valid()) {
286    return NULL;
287  }
288  return env->NewStringUTF(icuLocale.locale().getISO3Language());
289}
290
291static jobjectArray ICU_getISOCountriesNative(JNIEnv* env, jclass) {
292    return toStringArray(env, icu::Locale::getISOCountries());
293}
294
295static jobjectArray ICU_getISOLanguagesNative(JNIEnv* env, jclass) {
296    return toStringArray(env, icu::Locale::getISOLanguages());
297}
298
299static jobjectArray ICU_getAvailableLocalesNative(JNIEnv* env, jclass) {
300    return toStringArray(env, uloc_countAvailable, uloc_getAvailable);
301}
302
303static jobjectArray ICU_getAvailableBreakIteratorLocalesNative(JNIEnv* env, jclass) {
304    return toStringArray(env, ubrk_countAvailable, ubrk_getAvailable);
305}
306
307static jobjectArray ICU_getAvailableCalendarLocalesNative(JNIEnv* env, jclass) {
308    return toStringArray(env, ucal_countAvailable, ucal_getAvailable);
309}
310
311static jobjectArray ICU_getAvailableCollatorLocalesNative(JNIEnv* env, jclass) {
312    return toStringArray(env, ucol_countAvailable, ucol_getAvailable);
313}
314
315static jobjectArray ICU_getAvailableDateFormatLocalesNative(JNIEnv* env, jclass) {
316    return toStringArray(env, udat_countAvailable, udat_getAvailable);
317}
318
319static jobjectArray ICU_getAvailableNumberFormatLocalesNative(JNIEnv* env, jclass) {
320    return toStringArray(env, unum_countAvailable, unum_getAvailable);
321}
322
323static bool setIntegerField(JNIEnv* env, jobject obj, const char* fieldName, int value) {
324    ScopedLocalRef<jobject> integerValue(env, integerValueOf(env, value));
325    if (integerValue.get() == NULL) return false;
326    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "Ljava/lang/Integer;");
327    env->SetObjectField(obj, fid, integerValue.get());
328    return true;
329}
330
331static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, jstring value) {
332    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "Ljava/lang/String;");
333    env->SetObjectField(obj, fid, value);
334    env->DeleteLocalRef(value);
335}
336
337static void setStringArrayField(JNIEnv* env, jobject obj, const char* fieldName, jobjectArray value) {
338    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "[Ljava/lang/String;");
339    env->SetObjectField(obj, fid, value);
340}
341
342static void setStringArrayField(JNIEnv* env, jobject obj, const char* fieldName, const icu::UnicodeString* valueArray, int32_t size) {
343    ScopedLocalRef<jobjectArray> result(env, env->NewObjectArray(size, JniConstants::stringClass, NULL));
344    for (int32_t i = 0; i < size ; i++) {
345        ScopedLocalRef<jstring> s(env, env->NewString(valueArray[i].getBuffer(),valueArray[i].length()));
346        if (env->ExceptionCheck()) {
347            return;
348        }
349        env->SetObjectArrayElement(result.get(), i, s.get());
350        if (env->ExceptionCheck()) {
351            return;
352        }
353    }
354    setStringArrayField(env, obj, fieldName, result.get());
355}
356
357static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, UResourceBundle* bundle, int index) {
358  UErrorCode status = U_ZERO_ERROR;
359  int charCount;
360  const UChar* chars = ures_getStringByIndex(bundle, index, &charCount, &status);
361  if (U_SUCCESS(status)) {
362    setStringField(env, obj, fieldName, env->NewString(chars, charCount));
363  } else {
364    ALOGE("Error setting String field %s from ICU resource (index %d): %s", fieldName, index, u_errorName(status));
365  }
366}
367
368static void setCharField(JNIEnv* env, jobject obj, const char* fieldName, const icu::UnicodeString& value) {
369    if (value.length() == 0) {
370        return;
371    }
372    jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "C");
373    env->SetCharField(obj, fid, value.charAt(0));
374}
375
376static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, const icu::UnicodeString& value) {
377    const UChar* chars = value.getBuffer();
378    setStringField(env, obj, fieldName, env->NewString(chars, value.length()));
379}
380
381static void setNumberPatterns(JNIEnv* env, jobject obj, icu::Locale& locale) {
382    UErrorCode status = U_ZERO_ERROR;
383
384    icu::UnicodeString pattern;
385    std::unique_ptr<icu::DecimalFormat> fmt(static_cast<icu::DecimalFormat*>(icu::NumberFormat::createInstance(locale, UNUM_CURRENCY, status)));
386    pattern = fmt->toPattern(pattern.remove());
387    setStringField(env, obj, "currencyPattern", pattern);
388
389    fmt.reset(static_cast<icu::DecimalFormat*>(icu::NumberFormat::createInstance(locale, UNUM_DECIMAL, status)));
390    pattern = fmt->toPattern(pattern.remove());
391    setStringField(env, obj, "numberPattern", pattern);
392
393    fmt.reset(static_cast<icu::DecimalFormat*>(icu::NumberFormat::createInstance(locale, UNUM_PERCENT, status)));
394    pattern = fmt->toPattern(pattern.remove());
395    setStringField(env, obj, "percentPattern", pattern);
396}
397
398static void setDecimalFormatSymbolsData(JNIEnv* env, jobject obj, icu::Locale& locale) {
399    UErrorCode status = U_ZERO_ERROR;
400    icu::DecimalFormatSymbols dfs(locale, status);
401
402    setCharField(env, obj, "decimalSeparator", dfs.getSymbol(icu::DecimalFormatSymbols::kDecimalSeparatorSymbol));
403    setCharField(env, obj, "groupingSeparator", dfs.getSymbol(icu::DecimalFormatSymbols::kGroupingSeparatorSymbol));
404    setCharField(env, obj, "patternSeparator", dfs.getSymbol(icu::DecimalFormatSymbols::kPatternSeparatorSymbol));
405    setStringField(env, obj, "percent", dfs.getSymbol(icu::DecimalFormatSymbols::kPercentSymbol));
406    setCharField(env, obj, "perMill", dfs.getSymbol(icu::DecimalFormatSymbols::kPerMillSymbol));
407    setCharField(env, obj, "monetarySeparator", dfs.getSymbol(icu::DecimalFormatSymbols::kMonetarySeparatorSymbol));
408    setStringField(env, obj, "minusSign", dfs.getSymbol(icu::DecimalFormatSymbols:: kMinusSignSymbol));
409    setStringField(env, obj, "exponentSeparator", dfs.getSymbol(icu::DecimalFormatSymbols::kExponentialSymbol));
410    setStringField(env, obj, "infinity", dfs.getSymbol(icu::DecimalFormatSymbols::kInfinitySymbol));
411    setStringField(env, obj, "NaN", dfs.getSymbol(icu::DecimalFormatSymbols::kNaNSymbol));
412    setCharField(env, obj, "zeroDigit", dfs.getSymbol(icu::DecimalFormatSymbols::kZeroDigitSymbol));
413}
414
415
416// Iterates up through the locale hierarchy. So "en_US" would return "en_US", "en", "".
417class LocaleNameIterator {
418 public:
419  LocaleNameIterator(const char* locale_name, UErrorCode& status) : status_(status), has_next_(true) {
420    strcpy(locale_name_, locale_name);
421    locale_name_length_ = strlen(locale_name_);
422  }
423
424  const char* Get() {
425      return locale_name_;
426  }
427
428  bool HasNext() {
429    return has_next_;
430  }
431
432  void Up() {
433    if (locale_name_length_ == 0) {
434      has_next_ = false;
435    } else {
436      locale_name_length_ = uloc_getParent(locale_name_, locale_name_, sizeof(locale_name_), &status_);
437    }
438  }
439
440 private:
441  UErrorCode& status_;
442  bool has_next_;
443  char locale_name_[ULOC_FULLNAME_CAPACITY];
444  int32_t locale_name_length_;
445
446  DISALLOW_COPY_AND_ASSIGN(LocaleNameIterator);
447};
448
449static bool getAmPmMarkersNarrow(JNIEnv* env, jobject localeData, const char* locale_name) {
450  UErrorCode status = U_ZERO_ERROR;
451  ScopedResourceBundle root(ures_open(NULL, locale_name, &status));
452  if (U_FAILURE(status)) {
453    return false;
454  }
455  ScopedResourceBundle calendar(ures_getByKey(root.get(), "calendar", NULL, &status));
456  if (U_FAILURE(status)) {
457    return false;
458  }
459  ScopedResourceBundle gregorian(ures_getByKey(calendar.get(), "gregorian", NULL, &status));
460  if (U_FAILURE(status)) {
461    return false;
462  }
463  ScopedResourceBundle amPmMarkersNarrow(ures_getByKey(gregorian.get(), "AmPmMarkersNarrow", NULL, &status));
464  if (U_FAILURE(status)) {
465    return false;
466  }
467  setStringField(env, localeData, "narrowAm", amPmMarkersNarrow.get(), 0);
468  setStringField(env, localeData, "narrowPm", amPmMarkersNarrow.get(), 1);
469  return true;
470}
471
472static bool getDateTimePatterns(JNIEnv* env, jobject localeData, const char* locale_name) {
473  UErrorCode status = U_ZERO_ERROR;
474  ScopedResourceBundle root(ures_open(NULL, locale_name, &status));
475  if (U_FAILURE(status)) {
476    return false;
477  }
478  ScopedResourceBundle calendar(ures_getByKey(root.get(), "calendar", NULL, &status));
479  if (U_FAILURE(status)) {
480    return false;
481  }
482  ScopedResourceBundle gregorian(ures_getByKey(calendar.get(), "gregorian", NULL, &status));
483  if (U_FAILURE(status)) {
484    return false;
485  }
486  ScopedResourceBundle dateTimePatterns(ures_getByKey(gregorian.get(), "DateTimePatterns", NULL, &status));
487  if (U_FAILURE(status)) {
488    return false;
489  }
490  setStringField(env, localeData, "fullTimeFormat", dateTimePatterns.get(), 0);
491  setStringField(env, localeData, "longTimeFormat", dateTimePatterns.get(), 1);
492  setStringField(env, localeData, "mediumTimeFormat", dateTimePatterns.get(), 2);
493  setStringField(env, localeData, "shortTimeFormat", dateTimePatterns.get(), 3);
494  setStringField(env, localeData, "fullDateFormat", dateTimePatterns.get(), 4);
495  setStringField(env, localeData, "longDateFormat", dateTimePatterns.get(), 5);
496  setStringField(env, localeData, "mediumDateFormat", dateTimePatterns.get(), 6);
497  setStringField(env, localeData, "shortDateFormat", dateTimePatterns.get(), 7);
498  return true;
499}
500
501static bool getYesterdayTodayAndTomorrow(JNIEnv* env, jobject localeData, const icu::Locale& locale, const char* locale_name) {
502  UErrorCode status = U_ZERO_ERROR;
503  ScopedResourceBundle root(ures_open(NULL, locale_name, &status));
504  ScopedResourceBundle fields(ures_getByKey(root.get(), "fields", NULL, &status));
505  ScopedResourceBundle day(ures_getByKey(fields.get(), "day", NULL, &status));
506  ScopedResourceBundle relative(ures_getByKey(day.get(), "relative", NULL, &status));
507  if (U_FAILURE(status)) {
508    return false;
509  }
510
511  icu::UnicodeString yesterday(icu::ures_getUnicodeStringByKey(relative.get(), "-1", &status));
512  icu::UnicodeString today(icu::ures_getUnicodeStringByKey(relative.get(), "0", &status));
513  icu::UnicodeString tomorrow(icu::ures_getUnicodeStringByKey(relative.get(), "1", &status));
514  if (U_FAILURE(status)) {
515    ALOGE("Error getting yesterday/today/tomorrow for %s: %s", locale_name, u_errorName(status));
516    return false;
517  }
518
519  // We title-case the strings so they have consistent capitalization (http://b/14493853).
520  std::unique_ptr<icu::BreakIterator> brk(icu::BreakIterator::createSentenceInstance(locale, status));
521  if (U_FAILURE(status)) {
522    ALOGE("Error getting yesterday/today/tomorrow break iterator for %s: %s", locale_name, u_errorName(status));
523    return false;
524  }
525  yesterday.toTitle(brk.get(), locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
526  today.toTitle(brk.get(), locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
527  tomorrow.toTitle(brk.get(), locale, U_TITLECASE_NO_LOWERCASE | U_TITLECASE_NO_BREAK_ADJUSTMENT);
528
529  setStringField(env, localeData, "yesterday", yesterday);
530  setStringField(env, localeData, "today", today);
531  setStringField(env, localeData, "tomorrow", tomorrow);
532  return true;
533}
534
535static jboolean ICU_initLocaleDataNative(JNIEnv* env, jclass, jstring javaLanguageTag, jobject localeData) {
536    ScopedUtfChars languageTag(env, javaLanguageTag);
537    if (languageTag.c_str() == NULL) {
538        return JNI_FALSE;
539    }
540    if (languageTag.size() >= ULOC_FULLNAME_CAPACITY) {
541        return JNI_FALSE; // ICU has a fixed-length limit.
542    }
543
544    ScopedIcuLocale icuLocale(env, javaLanguageTag);
545    if (!icuLocale.valid()) {
546      return JNI_FALSE;
547    }
548
549    // Get the DateTimePatterns.
550    UErrorCode status = U_ZERO_ERROR;
551    bool foundDateTimePatterns = false;
552    for (LocaleNameIterator it(icuLocale.locale().getBaseName(), status); it.HasNext(); it.Up()) {
553      if (getDateTimePatterns(env, localeData, it.Get())) {
554          foundDateTimePatterns = true;
555          break;
556      }
557    }
558    if (!foundDateTimePatterns) {
559        ALOGE("Couldn't find ICU DateTimePatterns for %s", languageTag.c_str());
560        return JNI_FALSE;
561    }
562
563    // Get the "Yesterday", "Today", and "Tomorrow" strings.
564    bool foundYesterdayTodayAndTomorrow = false;
565    for (LocaleNameIterator it(icuLocale.locale().getBaseName(), status); it.HasNext(); it.Up()) {
566      if (getYesterdayTodayAndTomorrow(env, localeData, icuLocale.locale(), it.Get())) {
567        foundYesterdayTodayAndTomorrow = true;
568        break;
569      }
570    }
571    if (!foundYesterdayTodayAndTomorrow) {
572      ALOGE("Couldn't find ICU yesterday/today/tomorrow for %s", languageTag.c_str());
573      return JNI_FALSE;
574    }
575
576    // Get the narrow "AM" and "PM" strings.
577    bool foundAmPmMarkersNarrow = false;
578    for (LocaleNameIterator it(icuLocale.locale().getBaseName(), status); it.HasNext(); it.Up()) {
579      if (getAmPmMarkersNarrow(env, localeData, it.Get())) {
580        foundAmPmMarkersNarrow = true;
581        break;
582      }
583    }
584    if (!foundAmPmMarkersNarrow) {
585      ALOGE("Couldn't find ICU AmPmMarkersNarrow for %s", languageTag.c_str());
586      return JNI_FALSE;
587    }
588
589    status = U_ZERO_ERROR;
590    std::unique_ptr<icu::Calendar> cal(icu::Calendar::createInstance(icuLocale.locale(), status));
591    if (U_FAILURE(status)) {
592        return JNI_FALSE;
593    }
594    if (!setIntegerField(env, localeData, "firstDayOfWeek", cal->getFirstDayOfWeek())) {
595      return JNI_FALSE;
596    }
597    if (!setIntegerField(env, localeData, "minimalDaysInFirstWeek", cal->getMinimalDaysInFirstWeek())) {
598      return JNI_FALSE;
599    }
600
601    // Get DateFormatSymbols.
602    status = U_ZERO_ERROR;
603    icu::DateFormatSymbols dateFormatSym(icuLocale.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 icu::UnicodeString* amPmStrs = dateFormatSym.getAmPmStrings(count);
611    setStringArrayField(env, localeData, "amPm", amPmStrs, count);
612    const icu::UnicodeString* erasStrs = dateFormatSym.getEras(count);
613    setStringArrayField(env, localeData, "eras", erasStrs, count);
614
615    const icu::UnicodeString* longMonthNames =
616       dateFormatSym.getMonths(count, icu::DateFormatSymbols::FORMAT, icu::DateFormatSymbols::WIDE);
617    setStringArrayField(env, localeData, "longMonthNames", longMonthNames, count);
618    const icu::UnicodeString* shortMonthNames =
619        dateFormatSym.getMonths(count, icu::DateFormatSymbols::FORMAT, icu::DateFormatSymbols::ABBREVIATED);
620    setStringArrayField(env, localeData, "shortMonthNames", shortMonthNames, count);
621    const icu::UnicodeString* tinyMonthNames =
622        dateFormatSym.getMonths(count, icu::DateFormatSymbols::FORMAT, icu::DateFormatSymbols::NARROW);
623    setStringArrayField(env, localeData, "tinyMonthNames", tinyMonthNames, count);
624    const icu::UnicodeString* longWeekdayNames =
625        dateFormatSym.getWeekdays(count, icu::DateFormatSymbols::FORMAT, icu::DateFormatSymbols::WIDE);
626    setStringArrayField(env, localeData, "longWeekdayNames", longWeekdayNames, count);
627    const icu::UnicodeString* shortWeekdayNames =
628        dateFormatSym.getWeekdays(count, icu::DateFormatSymbols::FORMAT, icu::DateFormatSymbols::ABBREVIATED);
629    setStringArrayField(env, localeData, "shortWeekdayNames", shortWeekdayNames, count);
630    const icu::UnicodeString* tinyWeekdayNames =
631        dateFormatSym.getWeekdays(count, icu::DateFormatSymbols::FORMAT, icu::DateFormatSymbols::NARROW);
632    setStringArrayField(env, localeData, "tinyWeekdayNames", tinyWeekdayNames, count);
633
634    const icu::UnicodeString* longStandAloneMonthNames =
635        dateFormatSym.getMonths(count, icu::DateFormatSymbols::STANDALONE, icu::DateFormatSymbols::WIDE);
636    setStringArrayField(env, localeData, "longStandAloneMonthNames", longStandAloneMonthNames, count);
637    const icu::UnicodeString* shortStandAloneMonthNames =
638        dateFormatSym.getMonths(count, icu::DateFormatSymbols::STANDALONE, icu::DateFormatSymbols::ABBREVIATED);
639    setStringArrayField(env, localeData, "shortStandAloneMonthNames", shortStandAloneMonthNames, count);
640    const icu::UnicodeString* tinyStandAloneMonthNames =
641        dateFormatSym.getMonths(count, icu::DateFormatSymbols::STANDALONE, icu::DateFormatSymbols::NARROW);
642    setStringArrayField(env, localeData, "tinyStandAloneMonthNames", tinyStandAloneMonthNames, count);
643    const icu::UnicodeString* longStandAloneWeekdayNames =
644        dateFormatSym.getWeekdays(count, icu::DateFormatSymbols::STANDALONE, icu::DateFormatSymbols::WIDE);
645    setStringArrayField(env, localeData, "longStandAloneWeekdayNames", longStandAloneWeekdayNames, count);
646    const icu::UnicodeString* shortStandAloneWeekdayNames =
647        dateFormatSym.getWeekdays(count, icu::DateFormatSymbols::STANDALONE, icu::DateFormatSymbols::ABBREVIATED);
648    setStringArrayField(env, localeData, "shortStandAloneWeekdayNames", shortStandAloneWeekdayNames, count);
649    const icu::UnicodeString* tinyStandAloneWeekdayNames =
650        dateFormatSym.getWeekdays(count, icu::DateFormatSymbols::STANDALONE, icu::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, icuLocale.locale());
657    setDecimalFormatSymbolsData(env, localeData, icuLocale.locale());
658
659    jstring countryCode = env->NewStringUTF(icuLocale.locale().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, javaLanguageTag, 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 javaLanguageTag) {
681  ScopedJavaUnicodeString scopedString(env, javaString);
682  if (!scopedString.valid()) {
683    return NULL;
684  }
685  ScopedIcuLocale icuLocale(env, javaLanguageTag);
686  if (!icuLocale.valid()) {
687    return NULL;
688  }
689  icu::UnicodeString& s(scopedString.unicodeString());
690  icu::UnicodeString original(s);
691  s.toLower(icuLocale.locale());
692  return s == original ? javaString : env->NewString(s.getBuffer(), s.length());
693}
694
695static jstring ICU_toUpperCase(JNIEnv* env, jclass, jstring javaString, jstring javaLanguageTag) {
696  ScopedJavaUnicodeString scopedString(env, javaString);
697  if (!scopedString.valid()) {
698    return NULL;
699  }
700  ScopedIcuLocale icuLocale(env, javaLanguageTag);
701  if (!icuLocale.valid()) {
702    return NULL;
703  }
704  icu::UnicodeString& s(scopedString.unicodeString());
705  icu::UnicodeString original(s);
706  s.toUpper(icuLocale.locale());
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 jstring ICU_getTZDataVersion(JNIEnv* env, jclass) {
736  UErrorCode status = U_ZERO_ERROR;
737  const char* version = icu::TimeZone::getTZDataVersion(status);
738  if (maybeThrowIcuException(env, "icu::TimeZone::getTZDataVersion", status)) {
739    return NULL;
740  }
741  return env->NewStringUTF(version);
742}
743
744static jobject ICU_getAvailableCurrencyCodes(JNIEnv* env, jclass) {
745  UErrorCode status = U_ZERO_ERROR;
746  icu::UStringEnumeration e(ucurr_openISOCurrencies(UCURR_COMMON|UCURR_NON_DEPRECATED, &status));
747  return fromStringEnumeration(env, status, "ucurr_openISOCurrencies", &e);
748}
749
750static jstring ICU_getBestDateTimePatternNative(JNIEnv* env, jclass, jstring javaSkeleton, jstring javaLanguageTag) {
751  ScopedIcuLocale icuLocale(env, javaLanguageTag);
752  if (!icuLocale.valid()) {
753    return NULL;
754  }
755
756  UErrorCode status = U_ZERO_ERROR;
757  std::unique_ptr<icu::DateTimePatternGenerator> generator(icu::DateTimePatternGenerator::createInstance(icuLocale.locale(), status));
758  if (maybeThrowIcuException(env, "DateTimePatternGenerator::createInstance", status)) {
759    return NULL;
760  }
761
762  ScopedJavaUnicodeString skeletonHolder(env, javaSkeleton);
763  if (!skeletonHolder.valid()) {
764    return NULL;
765  }
766  icu::UnicodeString result(generator->getBestPattern(skeletonHolder.unicodeString(), status));
767  if (maybeThrowIcuException(env, "DateTimePatternGenerator::getBestPattern", status)) {
768    return NULL;
769  }
770
771  return env->NewString(result.getBuffer(), result.length());
772}
773
774static void ICU_setDefaultLocale(JNIEnv* env, jclass, jstring javaLanguageTag) {
775  ScopedIcuLocale icuLocale(env, javaLanguageTag);
776  if (!icuLocale.valid()) {
777    return;
778  }
779
780  UErrorCode status = U_ZERO_ERROR;
781  icu::Locale::setDefault(icuLocale.locale(), status);
782  maybeThrowIcuException(env, "Locale::setDefault", status);
783}
784
785static jstring ICU_getDefaultLocale(JNIEnv* env, jclass) {
786  return env->NewStringUTF(icu::Locale::getDefault().getName());
787}
788
789static JNINativeMethod gMethods[] = {
790    NATIVE_METHOD(ICU, addLikelySubtags, "(Ljava/lang/String;)Ljava/lang/String;"),
791    NATIVE_METHOD(ICU, getAvailableBreakIteratorLocalesNative, "()[Ljava/lang/String;"),
792    NATIVE_METHOD(ICU, getAvailableCalendarLocalesNative, "()[Ljava/lang/String;"),
793    NATIVE_METHOD(ICU, getAvailableCollatorLocalesNative, "()[Ljava/lang/String;"),
794    NATIVE_METHOD(ICU, getAvailableCurrencyCodes, "()[Ljava/lang/String;"),
795    NATIVE_METHOD(ICU, getAvailableDateFormatLocalesNative, "()[Ljava/lang/String;"),
796    NATIVE_METHOD(ICU, getAvailableLocalesNative, "()[Ljava/lang/String;"),
797    NATIVE_METHOD(ICU, getAvailableNumberFormatLocalesNative, "()[Ljava/lang/String;"),
798    NATIVE_METHOD(ICU, getBestDateTimePatternNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
799    NATIVE_METHOD(ICU, getCldrVersion, "()Ljava/lang/String;"),
800    NATIVE_METHOD(ICU, getCurrencyCode, "(Ljava/lang/String;)Ljava/lang/String;"),
801    NATIVE_METHOD(ICU, getCurrencyDisplayName, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
802    NATIVE_METHOD(ICU, getCurrencyFractionDigits, "(Ljava/lang/String;)I"),
803    NATIVE_METHOD(ICU, getCurrencyNumericCode, "(Ljava/lang/String;)I"),
804    NATIVE_METHOD(ICU, getCurrencySymbol, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
805    NATIVE_METHOD(ICU, getDefaultLocale, "()Ljava/lang/String;"),
806    NATIVE_METHOD(ICU, getDisplayCountryNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
807    NATIVE_METHOD(ICU, getDisplayLanguageNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
808    NATIVE_METHOD(ICU, getDisplayScriptNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
809    NATIVE_METHOD(ICU, getDisplayVariantNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
810    NATIVE_METHOD(ICU, getISO3Country, "(Ljava/lang/String;)Ljava/lang/String;"),
811    NATIVE_METHOD(ICU, getISO3Language, "(Ljava/lang/String;)Ljava/lang/String;"),
812    NATIVE_METHOD(ICU, getISOCountriesNative, "()[Ljava/lang/String;"),
813    NATIVE_METHOD(ICU, getISOLanguagesNative, "()[Ljava/lang/String;"),
814    NATIVE_METHOD(ICU, getIcuVersion, "()Ljava/lang/String;"),
815    NATIVE_METHOD(ICU, getScript, "(Ljava/lang/String;)Ljava/lang/String;"),
816    NATIVE_METHOD(ICU, getTZDataVersion, "()Ljava/lang/String;"),
817    NATIVE_METHOD(ICU, getUnicodeVersion, "()Ljava/lang/String;"),
818    NATIVE_METHOD(ICU, initLocaleDataNative, "(Ljava/lang/String;Llibcore/icu/LocaleData;)Z"),
819    NATIVE_METHOD(ICU, setDefaultLocale, "(Ljava/lang/String;)V"),
820    NATIVE_METHOD(ICU, toLowerCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
821    NATIVE_METHOD(ICU, toUpperCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
822};
823
824#define FAIL_WITH_STRERROR(s) \
825    ALOGE("Couldn't " s " '%s': %s", path.c_str(), strerror(errno)); \
826    return FALSE;
827
828#define MAYBE_FAIL_WITH_ICU_ERROR(s) \
829    if (status != U_ZERO_ERROR) {\
830        ALOGE("Couldn't initialize ICU (" s "): %s (%s)", u_errorName(status), path.c_str()); \
831        return FALSE; \
832    }
833
834static bool mapIcuData(const std::string& path) {
835    // Open the file and get its length.
836    ScopedFd fd(open(path.c_str(), O_RDONLY));
837    if (fd.get() == -1) {
838        FAIL_WITH_STRERROR("open");
839    }
840    struct stat sb;
841    if (fstat(fd.get(), &sb) == -1) {
842        FAIL_WITH_STRERROR("stat");
843    }
844
845    // Map it.
846    void* data = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd.get(), 0);
847    if (data == MAP_FAILED) {
848        FAIL_WITH_STRERROR("mmap");
849    }
850
851    // Tell the kernel that accesses are likely to be random rather than sequential.
852    if (madvise(data, sb.st_size, MADV_RANDOM) == -1) {
853        FAIL_WITH_STRERROR("madvise(MADV_RANDOM)");
854    }
855
856    UErrorCode status = U_ZERO_ERROR;
857
858    // Tell ICU to use our memory-mapped data.
859    udata_setCommonData(data, &status);
860    MAYBE_FAIL_WITH_ICU_ERROR("udata_setCommonData");
861
862    return TRUE;
863}
864
865void register_libcore_icu_ICU(JNIEnv* env) {
866    // Check the timezone override file exists. If it does, map it first so we use it in preference
867    // to the one that shipped with the device.
868    const char* dataPathPrefix = getenv("ANDROID_DATA");
869    if (dataPathPrefix == NULL) {
870        ALOGE("ANDROID_DATA environment variable not set"); \
871        abort();
872    }
873
874    UErrorCode status = U_ZERO_ERROR;
875    // Tell ICU it can *only* use our memory-mapped data.
876    udata_setFileAccess(UDATA_NO_FILES, &status);
877    if (status != U_ZERO_ERROR) {
878        ALOGE("Couldn't initialize ICU (s_setFileAccess): %s", u_errorName(status));
879        abort();
880    }
881
882    // Map in optional TZ data files.
883    std::string dataPath;
884    dataPath = dataPathPrefix;
885    dataPath += "/misc/zoneinfo/current/icu/icu_tzdata.dat";
886
887    struct stat sb;
888    if (stat(dataPath.c_str(), &sb) == 0) {
889        ALOGD("Timezone override file found: %s", dataPath.c_str());
890        if (!mapIcuData(dataPath)) {
891            ALOGW("TZ override file %s exists but could not be loaded. Skipping.", dataPath.c_str());
892        }
893    } else {
894        ALOGD("No timezone override file found: %s", dataPath.c_str());
895    }
896
897    // Use the ICU data files that shipped with the device for everything else.
898    const char* systemPathPrefix = getenv("ANDROID_ROOT");
899    if (systemPathPrefix == NULL) {
900        ALOGE("ANDROID_ROOT environment variable not set"); \
901        abort();
902    }
903    std::string systemPath;
904    systemPath = systemPathPrefix;
905    systemPath += "/usr/icu/";
906    systemPath += U_ICUDATA_NAME;
907    systemPath += ".dat";
908
909    if (!mapIcuData(systemPath)) {
910        abort();
911    }
912
913    // Failures to find the ICU data tend to be somewhat obscure because ICU loads its data on first
914    // use, which can be anywhere. Force initialization up front so we can report a nice clear error
915    // and bail.
916    u_init(&status);
917    if (status != U_ZERO_ERROR) {\
918        ALOGE("Couldn't initialize ICU (u_init): %s", u_errorName(status));
919        abort();
920    }
921
922    jniRegisterNativeMethods(env, "libcore/icu/ICU", gMethods, NELEM(gMethods));
923}
924