1 /*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "ICU"
18
19 #include "JNIHelp.h"
20 #include "JniConstants.h"
21 #include "JniException.h"
22 #include "ScopedFd.h"
23 #include "ScopedJavaUnicodeString.h"
24 #include "ScopedLocalRef.h"
25 #include "ScopedStringChars.h"
26 #include "ScopedUtfChars.h"
27 #include "UniquePtr.h"
28 #include "cutils/log.h"
29 #include "toStringArray.h"
30 #include "unicode/calendar.h"
31 #include "unicode/datefmt.h"
32 #include "unicode/dcfmtsym.h"
33 #include "unicode/decimfmt.h"
34 #include "unicode/dtfmtsym.h"
35 #include "unicode/gregocal.h"
36 #include "unicode/locid.h"
37 #include "unicode/numfmt.h"
38 #include "unicode/strenum.h"
39 #include "unicode/ubrk.h"
40 #include "unicode/ucal.h"
41 #include "unicode/uclean.h"
42 #include "unicode/ucol.h"
43 #include "unicode/ucurr.h"
44 #include "unicode/udat.h"
45 #include "unicode/uloc.h"
46 #include "unicode/ustring.h"
47 #include "ureslocs.h"
48 #include "valueOf.h"
49
50 #include <errno.h>
51 #include <fcntl.h>
52 #include <stdlib.h>
53 #include <string.h>
54 #include <string>
55 #include <sys/mman.h>
56 #include <sys/stat.h>
57 #include <sys/time.h>
58 #include <sys/types.h>
59 #include <time.h>
60 #include <unistd.h>
61
62 class ScopedResourceBundle {
63 public:
ScopedResourceBundle(UResourceBundle * bundle)64 ScopedResourceBundle(UResourceBundle* bundle) : mBundle(bundle) {
65 }
66
~ScopedResourceBundle()67 ~ScopedResourceBundle() {
68 if (mBundle != NULL) {
69 ures_close(mBundle);
70 }
71 }
72
get()73 UResourceBundle* get() {
74 return mBundle;
75 }
76
77 private:
78 UResourceBundle* mBundle;
79
80 // Disallow copy and assignment.
81 ScopedResourceBundle(const ScopedResourceBundle&);
82 void operator=(const ScopedResourceBundle&);
83 };
84
getLocale(JNIEnv * env,jstring localeName)85 Locale getLocale(JNIEnv* env, jstring localeName) {
86 return Locale::createFromName(ScopedUtfChars(env, localeName).c_str());
87 }
88
ICU_addLikelySubtags(JNIEnv * env,jclass,jstring javaLocale)89 static jstring ICU_addLikelySubtags(JNIEnv* env, jclass, jstring javaLocale) {
90 UErrorCode status = U_ZERO_ERROR;
91 ScopedUtfChars localeID(env, javaLocale);
92 char maximizedLocaleID[ULOC_FULLNAME_CAPACITY];
93 uloc_addLikelySubtags(localeID.c_str(), maximizedLocaleID, sizeof(maximizedLocaleID), &status);
94 if (U_FAILURE(status)) {
95 return javaLocale;
96 }
97 return env->NewStringUTF(maximizedLocaleID);
98 }
99
ICU_getScript(JNIEnv * env,jclass,jstring javaLocale)100 static jstring ICU_getScript(JNIEnv* env, jclass, jstring javaLocale) {
101 UErrorCode status = U_ZERO_ERROR;
102 ScopedUtfChars localeID(env, javaLocale);
103 char script[ULOC_SCRIPT_CAPACITY];
104 uloc_getScript(localeID.c_str(), script, sizeof(script), &status);
105 if (U_FAILURE(status)) {
106 return NULL;
107 }
108 return env->NewStringUTF(script);
109 }
110
ICU_getCurrencyFractionDigits(JNIEnv * env,jclass,jstring javaCurrencyCode)111 static jint ICU_getCurrencyFractionDigits(JNIEnv* env, jclass, jstring javaCurrencyCode) {
112 ScopedJavaUnicodeString currencyCode(env, javaCurrencyCode);
113 UnicodeString icuCurrencyCode(currencyCode.unicodeString());
114 UErrorCode status = U_ZERO_ERROR;
115 return ucurr_getDefaultFractionDigits(icuCurrencyCode.getTerminatedBuffer(), &status);
116 }
117
ICU_getCurrencyCode(JNIEnv * env,jclass,jstring javaCountryCode)118 static jstring ICU_getCurrencyCode(JNIEnv* env, jclass, jstring javaCountryCode) {
119 UErrorCode status = U_ZERO_ERROR;
120 ScopedResourceBundle supplData(ures_openDirect(U_ICUDATA_CURR, "supplementalData", &status));
121 if (U_FAILURE(status)) {
122 return NULL;
123 }
124
125 ScopedResourceBundle currencyMap(ures_getByKey(supplData.get(), "CurrencyMap", NULL, &status));
126 if (U_FAILURE(status)) {
127 return NULL;
128 }
129
130 ScopedUtfChars countryCode(env, javaCountryCode);
131 ScopedResourceBundle currency(ures_getByKey(currencyMap.get(), countryCode.c_str(), NULL, &status));
132 if (U_FAILURE(status)) {
133 return NULL;
134 }
135
136 ScopedResourceBundle currencyElem(ures_getByIndex(currency.get(), 0, NULL, &status));
137 if (U_FAILURE(status)) {
138 return env->NewStringUTF("XXX");
139 }
140
141 // Check if there's a 'to' date. If there is, the currency isn't used anymore.
142 ScopedResourceBundle currencyTo(ures_getByKey(currencyElem.get(), "to", NULL, &status));
143 if (!U_FAILURE(status)) {
144 return NULL;
145 }
146 // Ignore the failure to find a 'to' date.
147 status = U_ZERO_ERROR;
148
149 ScopedResourceBundle currencyId(ures_getByKey(currencyElem.get(), "id", NULL, &status));
150 if (U_FAILURE(status)) {
151 // No id defined for this country
152 return env->NewStringUTF("XXX");
153 }
154
155 int32_t charCount;
156 const jchar* chars = ures_getString(currencyId.get(), &charCount, &status);
157 return (charCount == 0) ? env->NewStringUTF("XXX") : env->NewString(chars, charCount);
158 }
159
ICU_getCurrencyDisplayName(JNIEnv * env,jclass,jstring javaLocaleName,jstring javaCurrencyCode)160 static jstring ICU_getCurrencyDisplayName(JNIEnv* env, jclass, jstring javaLocaleName, jstring javaCurrencyCode) {
161 ScopedUtfChars localeName(env, javaLocaleName);
162 ScopedJavaUnicodeString currencyCode(env, javaCurrencyCode);
163 UnicodeString icuCurrencyCode(currencyCode.unicodeString());
164 UErrorCode status = U_ZERO_ERROR;
165 UBool isChoiceFormat;
166 int32_t charCount;
167 const UChar* chars = ucurr_getName(icuCurrencyCode.getTerminatedBuffer(), localeName.c_str(),
168 UCURR_LONG_NAME, &isChoiceFormat, &charCount, &status);
169 if (status == U_USING_DEFAULT_WARNING) {
170 // ICU's default is English. We want the ISO 4217 currency code instead.
171 chars = icuCurrencyCode.getBuffer();
172 charCount = icuCurrencyCode.length();
173 }
174 return (charCount == 0) ? NULL : env->NewString(chars, charCount);
175 }
176
ICU_getCurrencySymbol(JNIEnv * env,jclass,jstring locale,jstring currencyCode)177 static jstring ICU_getCurrencySymbol(JNIEnv* env, jclass, jstring locale, jstring currencyCode) {
178 // We can't use ucurr_getName because it doesn't distinguish between using data root from
179 // the root locale and parroting back the input because it's never heard of the currency code.
180 ScopedUtfChars localeName(env, locale);
181 UErrorCode status = U_ZERO_ERROR;
182 ScopedResourceBundle currLoc(ures_open(U_ICUDATA_CURR, localeName.c_str(), &status));
183 if (U_FAILURE(status)) {
184 return NULL;
185 }
186
187 ScopedResourceBundle currencies(ures_getByKey(currLoc.get(), "Currencies", NULL, &status));
188 if (U_FAILURE(status)) {
189 return NULL;
190 }
191
192 ScopedUtfChars currency(env, currencyCode);
193 ScopedResourceBundle currencyElems(ures_getByKey(currencies.get(), currency.c_str(), NULL, &status));
194 if (U_FAILURE(status)) {
195 return NULL;
196 }
197
198 int32_t charCount;
199 const jchar* chars = ures_getStringByIndex(currencyElems.get(), 0, &charCount, &status);
200 if (U_FAILURE(status)) {
201 return NULL;
202 }
203 return (charCount == 0) ? NULL : env->NewString(chars, charCount);
204 }
205
ICU_getDisplayCountryNative(JNIEnv * env,jclass,jstring targetLocale,jstring locale)206 static jstring ICU_getDisplayCountryNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
207 Locale loc = getLocale(env, locale);
208 Locale targetLoc = getLocale(env, targetLocale);
209 UnicodeString str;
210 targetLoc.getDisplayCountry(loc, str);
211 return env->NewString(str.getBuffer(), str.length());
212 }
213
ICU_getDisplayLanguageNative(JNIEnv * env,jclass,jstring targetLocale,jstring locale)214 static jstring ICU_getDisplayLanguageNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
215 Locale loc = getLocale(env, locale);
216 Locale targetLoc = getLocale(env, targetLocale);
217 UnicodeString str;
218 targetLoc.getDisplayLanguage(loc, str);
219 return env->NewString(str.getBuffer(), str.length());
220 }
221
ICU_getDisplayVariantNative(JNIEnv * env,jclass,jstring targetLocale,jstring locale)222 static jstring ICU_getDisplayVariantNative(JNIEnv* env, jclass, jstring targetLocale, jstring locale) {
223 Locale loc = getLocale(env, locale);
224 Locale targetLoc = getLocale(env, targetLocale);
225 UnicodeString str;
226 targetLoc.getDisplayVariant(loc, str);
227 return env->NewString(str.getBuffer(), str.length());
228 }
229
ICU_getISO3CountryNative(JNIEnv * env,jclass,jstring locale)230 static jstring ICU_getISO3CountryNative(JNIEnv* env, jclass, jstring locale) {
231 Locale loc = getLocale(env, locale);
232 return env->NewStringUTF(loc.getISO3Country());
233 }
234
ICU_getISO3LanguageNative(JNIEnv * env,jclass,jstring locale)235 static jstring ICU_getISO3LanguageNative(JNIEnv* env, jclass, jstring locale) {
236 Locale loc = getLocale(env, locale);
237 return env->NewStringUTF(loc.getISO3Language());
238 }
239
ICU_getISOCountriesNative(JNIEnv * env,jclass)240 static jobjectArray ICU_getISOCountriesNative(JNIEnv* env, jclass) {
241 return toStringArray(env, Locale::getISOCountries());
242 }
243
ICU_getISOLanguagesNative(JNIEnv * env,jclass)244 static jobjectArray ICU_getISOLanguagesNative(JNIEnv* env, jclass) {
245 return toStringArray(env, Locale::getISOLanguages());
246 }
247
ICU_getAvailableLocalesNative(JNIEnv * env,jclass)248 static jobjectArray ICU_getAvailableLocalesNative(JNIEnv* env, jclass) {
249 return toStringArray(env, uloc_countAvailable, uloc_getAvailable);
250 }
251
ICU_getAvailableBreakIteratorLocalesNative(JNIEnv * env,jclass)252 static jobjectArray ICU_getAvailableBreakIteratorLocalesNative(JNIEnv* env, jclass) {
253 return toStringArray(env, ubrk_countAvailable, ubrk_getAvailable);
254 }
255
ICU_getAvailableCalendarLocalesNative(JNIEnv * env,jclass)256 static jobjectArray ICU_getAvailableCalendarLocalesNative(JNIEnv* env, jclass) {
257 return toStringArray(env, ucal_countAvailable, ucal_getAvailable);
258 }
259
ICU_getAvailableCollatorLocalesNative(JNIEnv * env,jclass)260 static jobjectArray ICU_getAvailableCollatorLocalesNative(JNIEnv* env, jclass) {
261 return toStringArray(env, ucol_countAvailable, ucol_getAvailable);
262 }
263
ICU_getAvailableDateFormatLocalesNative(JNIEnv * env,jclass)264 static jobjectArray ICU_getAvailableDateFormatLocalesNative(JNIEnv* env, jclass) {
265 return toStringArray(env, udat_countAvailable, udat_getAvailable);
266 }
267
ICU_getAvailableNumberFormatLocalesNative(JNIEnv * env,jclass)268 static jobjectArray ICU_getAvailableNumberFormatLocalesNative(JNIEnv* env, jclass) {
269 return toStringArray(env, unum_countAvailable, unum_getAvailable);
270 }
271
setIntegerField(JNIEnv * env,jobject obj,const char * fieldName,int value)272 static void setIntegerField(JNIEnv* env, jobject obj, const char* fieldName, int value) {
273 ScopedLocalRef<jobject> integerValue(env, integerValueOf(env, value));
274 jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "Ljava/lang/Integer;");
275 env->SetObjectField(obj, fid, integerValue.get());
276 }
277
setStringField(JNIEnv * env,jobject obj,const char * fieldName,jstring value)278 static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, jstring value) {
279 jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "Ljava/lang/String;");
280 env->SetObjectField(obj, fid, value);
281 env->DeleteLocalRef(value);
282 }
283
setStringArrayField(JNIEnv * env,jobject obj,const char * fieldName,jobjectArray value)284 static void setStringArrayField(JNIEnv* env, jobject obj, const char* fieldName, jobjectArray value) {
285 jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "[Ljava/lang/String;");
286 env->SetObjectField(obj, fid, value);
287 }
288
setStringArrayField(JNIEnv * env,jobject obj,const char * fieldName,const UnicodeString * valueArray,int32_t size)289 static void setStringArrayField(JNIEnv* env, jobject obj, const char* fieldName, const UnicodeString* valueArray, int32_t size) {
290 ScopedLocalRef<jobjectArray> result(env, env->NewObjectArray(size, JniConstants::stringClass, NULL));
291 for (int32_t i = 0; i < size ; i++) {
292 ScopedLocalRef<jstring> s(env, env->NewString(valueArray[i].getBuffer(),valueArray[i].length()));
293 if (env->ExceptionCheck()) {
294 return;
295 }
296 env->SetObjectArrayElement(result.get(), i, s.get());
297 if (env->ExceptionCheck()) {
298 return;
299 }
300 }
301 setStringArrayField(env, obj, fieldName, result.get());
302 }
303
setStringField(JNIEnv * env,jobject obj,const char * fieldName,UResourceBundle * bundle,int index)304 static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, UResourceBundle* bundle, int index) {
305 UErrorCode status = U_ZERO_ERROR;
306 int charCount;
307 const UChar* chars = ures_getStringByIndex(bundle, index, &charCount, &status);
308 if (U_SUCCESS(status)) {
309 setStringField(env, obj, fieldName, env->NewString(chars, charCount));
310 } else {
311 ALOGE("Error setting String field %s from ICU resource: %s", fieldName, u_errorName(status));
312 }
313 }
314
setCharField(JNIEnv * env,jobject obj,const char * fieldName,const UnicodeString & value)315 static void setCharField(JNIEnv* env, jobject obj, const char* fieldName, const UnicodeString& value) {
316 if (value.length() == 0) {
317 return;
318 }
319 jfieldID fid = env->GetFieldID(JniConstants::localeDataClass, fieldName, "C");
320 env->SetCharField(obj, fid, value.charAt(0));
321 }
322
setStringField(JNIEnv * env,jobject obj,const char * fieldName,const UnicodeString & value)323 static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, const UnicodeString& value) {
324 const UChar* chars = value.getBuffer();
325 setStringField(env, obj, fieldName, env->NewString(chars, value.length()));
326 }
327
setNumberPatterns(JNIEnv * env,jobject obj,jstring locale)328 static void setNumberPatterns(JNIEnv* env, jobject obj, jstring locale) {
329 UErrorCode status = U_ZERO_ERROR;
330 Locale localeObj = getLocale(env, locale);
331
332 UnicodeString pattern;
333 UniquePtr<DecimalFormat> fmt(static_cast<DecimalFormat*>(NumberFormat::createInstance(localeObj, UNUM_CURRENCY, status)));
334 pattern = fmt->toPattern(pattern.remove());
335 setStringField(env, obj, "currencyPattern", pattern);
336
337 fmt.reset(static_cast<DecimalFormat*>(NumberFormat::createInstance(localeObj, UNUM_DECIMAL, status)));
338 pattern = fmt->toPattern(pattern.remove());
339 setStringField(env, obj, "numberPattern", pattern);
340
341 fmt.reset(static_cast<DecimalFormat*>(NumberFormat::createInstance(localeObj, UNUM_PERCENT, status)));
342 pattern = fmt->toPattern(pattern.remove());
343 setStringField(env, obj, "percentPattern", pattern);
344 }
345
setDecimalFormatSymbolsData(JNIEnv * env,jobject obj,jstring locale)346 static void setDecimalFormatSymbolsData(JNIEnv* env, jobject obj, jstring locale) {
347 UErrorCode status = U_ZERO_ERROR;
348 Locale localeObj = getLocale(env, locale);
349 DecimalFormatSymbols dfs(localeObj, status);
350
351 setCharField(env, obj, "decimalSeparator", dfs.getSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol));
352 setCharField(env, obj, "groupingSeparator", dfs.getSymbol(DecimalFormatSymbols::kGroupingSeparatorSymbol));
353 setCharField(env, obj, "patternSeparator", dfs.getSymbol(DecimalFormatSymbols::kPatternSeparatorSymbol));
354 setCharField(env, obj, "percent", dfs.getSymbol(DecimalFormatSymbols::kPercentSymbol));
355 setCharField(env, obj, "perMill", dfs.getSymbol(DecimalFormatSymbols::kPerMillSymbol));
356 setCharField(env, obj, "monetarySeparator", dfs.getSymbol(DecimalFormatSymbols::kMonetarySeparatorSymbol));
357 setCharField(env, obj, "minusSign", dfs.getSymbol(DecimalFormatSymbols:: kMinusSignSymbol));
358 setStringField(env, obj, "exponentSeparator", dfs.getSymbol(DecimalFormatSymbols::kExponentialSymbol));
359 setStringField(env, obj, "infinity", dfs.getSymbol(DecimalFormatSymbols::kInfinitySymbol));
360 setStringField(env, obj, "NaN", dfs.getSymbol(DecimalFormatSymbols::kNaNSymbol));
361 setCharField(env, obj, "zeroDigit", dfs.getSymbol(DecimalFormatSymbols::kZeroDigitSymbol));
362 }
363
ICU_initLocaleDataImpl(JNIEnv * env,jclass,jstring locale,jobject localeData)364 static jboolean ICU_initLocaleDataImpl(JNIEnv* env, jclass, jstring locale, jobject localeData) {
365 ScopedUtfChars localeName(env, locale);
366 if (localeName.c_str() == NULL) {
367 return JNI_FALSE;
368 }
369
370 // Get DateTimePatterns
371 UErrorCode status;
372 char currentLocale[ULOC_FULLNAME_CAPACITY];
373 int32_t localeNameLen = 0;
374 if (localeName.size() >= ULOC_FULLNAME_CAPACITY) {
375 return JNI_FALSE; // Exceed ICU defined limit of the whole locale ID.
376 }
377 strcpy(currentLocale, localeName.c_str());
378 do {
379 status = U_ZERO_ERROR;
380 ScopedResourceBundle root(ures_open(NULL, currentLocale, &status));
381 if (U_FAILURE(status)) {
382 if (localeNameLen == 0) {
383 break; // No parent locale, report this error outside the loop.
384 } else {
385 status = U_ZERO_ERROR;
386 continue; // get parent locale.
387 }
388 }
389 ScopedResourceBundle calendar(ures_getByKey(root.get(), "calendar", NULL, &status));
390 if (U_FAILURE(status)) {
391 status = U_ZERO_ERROR;
392 continue; // get parent locale.
393 }
394
395 ScopedResourceBundle gregorian(ures_getByKey(calendar.get(), "gregorian", NULL, &status));
396 if (U_FAILURE(status)) {
397 status = U_ZERO_ERROR;
398 continue; // get parent locale.
399 }
400 ScopedResourceBundle dateTimePatterns(ures_getByKey(gregorian.get(), "DateTimePatterns", NULL, &status));
401 if (U_SUCCESS(status)) {
402 setStringField(env, localeData, "fullTimeFormat", dateTimePatterns.get(), 0);
403 setStringField(env, localeData, "longTimeFormat", dateTimePatterns.get(), 1);
404 setStringField(env, localeData, "mediumTimeFormat", dateTimePatterns.get(), 2);
405 setStringField(env, localeData, "shortTimeFormat", dateTimePatterns.get(), 3);
406 setStringField(env, localeData, "fullDateFormat", dateTimePatterns.get(), 4);
407 setStringField(env, localeData, "longDateFormat", dateTimePatterns.get(), 5);
408 setStringField(env, localeData, "mediumDateFormat", dateTimePatterns.get(), 6);
409 setStringField(env, localeData, "shortDateFormat", dateTimePatterns.get(), 7);
410 break;
411 } else {
412 status = U_ZERO_ERROR; // get parent locale.
413 }
414 } while((localeNameLen = uloc_getParent(currentLocale, currentLocale, sizeof(currentLocale), &status)) >= 0);
415 if (U_FAILURE(status)) {
416 ALOGE("Error getting ICU resource bundle: %s", u_errorName(status));
417 return JNI_FALSE;
418 }
419
420 status = U_ZERO_ERROR;
421 Locale localeObj = getLocale(env, locale);
422
423 UniquePtr<Calendar> cal(Calendar::createInstance(localeObj, status));
424 if (U_FAILURE(status)) {
425 return JNI_FALSE;
426 }
427 setIntegerField(env, localeData, "firstDayOfWeek", cal->getFirstDayOfWeek());
428 setIntegerField(env, localeData, "minimalDaysInFirstWeek", cal->getMinimalDaysInFirstWeek());
429
430 // Get DateFormatSymbols
431 status = U_ZERO_ERROR;
432 DateFormatSymbols dateFormatSym(localeObj, status);
433 if (U_FAILURE(status)) {
434 return JNI_FALSE;
435 }
436 int32_t count = 0;
437 // Get AM/PM marker
438 const UnicodeString* amPmStrs = dateFormatSym.getAmPmStrings(count);
439 setStringArrayField(env, localeData, "amPm", amPmStrs, count);
440 const UnicodeString* erasStrs = dateFormatSym.getEras(count);
441 setStringArrayField(env, localeData, "eras", erasStrs, count);
442
443 const UnicodeString* longMonthNames =
444 dateFormatSym.getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
445 setStringArrayField(env, localeData, "longMonthNames", longMonthNames, count);
446 const UnicodeString* shortMonthNames =
447 dateFormatSym.getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
448 setStringArrayField(env, localeData, "shortMonthNames", shortMonthNames, count);
449 const UnicodeString* longWeekdayNames =
450 dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
451 setStringArrayField(env, localeData, "longWeekdayNames", longWeekdayNames, count);
452 const UnicodeString* shortWeekdayNames =
453 dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
454 setStringArrayField(env, localeData, "shortWeekdayNames", shortWeekdayNames, count);
455
456 const UnicodeString* longStandAloneMonthNames =
457 dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
458 setStringArrayField(env, localeData, "longStandAloneMonthNames", longStandAloneMonthNames, count);
459 const UnicodeString* shortStandAloneMonthNames =
460 dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
461 setStringArrayField(env, localeData, "shortStandAloneMonthNames", shortStandAloneMonthNames, count);
462 const UnicodeString* longStandAloneWeekdayNames =
463 dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
464 setStringArrayField(env, localeData, "longStandAloneWeekdayNames", longStandAloneWeekdayNames, count);
465 const UnicodeString* shortStandAloneWeekdayNames =
466 dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
467 setStringArrayField(env, localeData, "shortStandAloneWeekdayNames", shortStandAloneWeekdayNames, count);
468
469 status = U_ZERO_ERROR;
470
471 // For numberPatterns and symbols.
472 setNumberPatterns(env, localeData, locale);
473 setDecimalFormatSymbolsData(env, localeData, locale);
474
475 jstring countryCode = env->NewStringUTF(Locale::createFromName(localeName.c_str()).getCountry());
476 jstring internationalCurrencySymbol = ICU_getCurrencyCode(env, NULL, countryCode);
477 env->DeleteLocalRef(countryCode);
478 countryCode = NULL;
479
480 jstring currencySymbol = NULL;
481 if (internationalCurrencySymbol != NULL) {
482 currencySymbol = ICU_getCurrencySymbol(env, NULL, locale, internationalCurrencySymbol);
483 } else {
484 internationalCurrencySymbol = env->NewStringUTF("XXX");
485 }
486 if (currencySymbol == NULL) {
487 // This is the UTF-8 encoding of U+00A4 (CURRENCY SIGN).
488 currencySymbol = env->NewStringUTF("\xc2\xa4");
489 }
490 setStringField(env, localeData, "currencySymbol", currencySymbol);
491 setStringField(env, localeData, "internationalCurrencySymbol", internationalCurrencySymbol);
492
493 return JNI_TRUE;
494 }
495
ICU_toLowerCase(JNIEnv * env,jclass,jstring javaString,jstring localeName)496 static jstring ICU_toLowerCase(JNIEnv* env, jclass, jstring javaString, jstring localeName) {
497 ScopedJavaUnicodeString scopedString(env, javaString);
498 UnicodeString& s(scopedString.unicodeString());
499 UnicodeString original(s);
500 s.toLower(Locale::createFromName(ScopedUtfChars(env, localeName).c_str()));
501 return s == original ? javaString : env->NewString(s.getBuffer(), s.length());
502 }
503
ICU_toUpperCase(JNIEnv * env,jclass,jstring javaString,jstring localeName)504 static jstring ICU_toUpperCase(JNIEnv* env, jclass, jstring javaString, jstring localeName) {
505 ScopedJavaUnicodeString scopedString(env, javaString);
506 UnicodeString& s(scopedString.unicodeString());
507 UnicodeString original(s);
508 s.toUpper(Locale::createFromName(ScopedUtfChars(env, localeName).c_str()));
509 return s == original ? javaString : env->NewString(s.getBuffer(), s.length());
510 }
511
versionString(JNIEnv * env,const UVersionInfo & version)512 static jstring versionString(JNIEnv* env, const UVersionInfo& version) {
513 char versionString[U_MAX_VERSION_STRING_LENGTH];
514 u_versionToString(const_cast<UVersionInfo&>(version), &versionString[0]);
515 return env->NewStringUTF(versionString);
516 }
517
ICU_getIcuVersion(JNIEnv * env,jclass)518 static jstring ICU_getIcuVersion(JNIEnv* env, jclass) {
519 UVersionInfo icuVersion;
520 u_getVersion(icuVersion);
521 return versionString(env, icuVersion);
522 }
523
ICU_getUnicodeVersion(JNIEnv * env,jclass)524 static jstring ICU_getUnicodeVersion(JNIEnv* env, jclass) {
525 UVersionInfo unicodeVersion;
526 u_getUnicodeVersion(unicodeVersion);
527 return versionString(env, unicodeVersion);
528 }
529
530
531 struct EnumerationCounter {
532 const size_t count;
EnumerationCounterEnumerationCounter533 EnumerationCounter(size_t count) : count(count) {}
operator ()EnumerationCounter534 size_t operator()() { return count; }
535 };
536 struct EnumerationGetter {
537 UEnumeration* e;
538 UErrorCode* status;
EnumerationGetterEnumerationGetter539 EnumerationGetter(UEnumeration* e, UErrorCode* status) : e(e), status(status) {}
operator ()EnumerationGetter540 const UChar* operator()(int32_t* charCount) { return uenum_unext(e, charCount, status); }
541 };
ICU_getAvailableCurrencyCodes(JNIEnv * env,jclass)542 static jobject ICU_getAvailableCurrencyCodes(JNIEnv* env, jclass) {
543 UErrorCode status = U_ZERO_ERROR;
544 UEnumeration* e(ucurr_openISOCurrencies(UCURR_COMMON|UCURR_NON_DEPRECATED, &status));
545 EnumerationCounter counter(uenum_count(e, &status));
546 EnumerationGetter getter(e, &status);
547 jobject result = toStringArray16(env, &counter, &getter);
548 maybeThrowIcuException(env, status);
549 uenum_close(e);
550 return result;
551 }
552
553 static JNINativeMethod gMethods[] = {
554 NATIVE_METHOD(ICU, addLikelySubtags, "(Ljava/lang/String;)Ljava/lang/String;"),
555 NATIVE_METHOD(ICU, getAvailableBreakIteratorLocalesNative, "()[Ljava/lang/String;"),
556 NATIVE_METHOD(ICU, getAvailableCalendarLocalesNative, "()[Ljava/lang/String;"),
557 NATIVE_METHOD(ICU, getAvailableCollatorLocalesNative, "()[Ljava/lang/String;"),
558 NATIVE_METHOD(ICU, getAvailableCurrencyCodes, "()[Ljava/lang/String;"),
559 NATIVE_METHOD(ICU, getAvailableDateFormatLocalesNative, "()[Ljava/lang/String;"),
560 NATIVE_METHOD(ICU, getAvailableLocalesNative, "()[Ljava/lang/String;"),
561 NATIVE_METHOD(ICU, getAvailableNumberFormatLocalesNative, "()[Ljava/lang/String;"),
562 NATIVE_METHOD(ICU, getCurrencyCode, "(Ljava/lang/String;)Ljava/lang/String;"),
563 NATIVE_METHOD(ICU, getCurrencyDisplayName, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
564 NATIVE_METHOD(ICU, getCurrencyFractionDigits, "(Ljava/lang/String;)I"),
565 NATIVE_METHOD(ICU, getCurrencySymbol, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
566 NATIVE_METHOD(ICU, getDisplayCountryNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
567 NATIVE_METHOD(ICU, getDisplayLanguageNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
568 NATIVE_METHOD(ICU, getDisplayVariantNative, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
569 NATIVE_METHOD(ICU, getISO3CountryNative, "(Ljava/lang/String;)Ljava/lang/String;"),
570 NATIVE_METHOD(ICU, getISO3LanguageNative, "(Ljava/lang/String;)Ljava/lang/String;"),
571 NATIVE_METHOD(ICU, getISOCountriesNative, "()[Ljava/lang/String;"),
572 NATIVE_METHOD(ICU, getISOLanguagesNative, "()[Ljava/lang/String;"),
573 NATIVE_METHOD(ICU, getIcuVersion, "()Ljava/lang/String;"),
574 NATIVE_METHOD(ICU, getScript, "(Ljava/lang/String;)Ljava/lang/String;"),
575 NATIVE_METHOD(ICU, getUnicodeVersion, "()Ljava/lang/String;"),
576 NATIVE_METHOD(ICU, initLocaleDataImpl, "(Ljava/lang/String;Llibcore/icu/LocaleData;)Z"),
577 NATIVE_METHOD(ICU, toLowerCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
578 NATIVE_METHOD(ICU, toUpperCase, "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;"),
579 };
register_libcore_icu_ICU(JNIEnv * env)580 void register_libcore_icu_ICU(JNIEnv* env) {
581 std::string path;
582 path = u_getDataDirectory();
583 path += "/";
584 path += U_ICUDATA_NAME;
585 path += ".dat";
586
587 #define FAIL_WITH_STRERROR(s) \
588 ALOGE("Couldn't " s " '%s': %s", path.c_str(), strerror(errno)); \
589 abort();
590 #define MAYBE_FAIL_WITH_ICU_ERROR(s) \
591 if (status != U_ZERO_ERROR) {\
592 ALOGE("Couldn't initialize ICU (" s "): %s (%s)", u_errorName(status), path.c_str()); \
593 abort(); \
594 }
595
596 // Open the file and get its length.
597 ScopedFd fd(open(path.c_str(), O_RDONLY));
598 if (fd.get() == -1) {
599 FAIL_WITH_STRERROR("open");
600 }
601 struct stat sb;
602 if (fstat(fd.get(), &sb) == -1) {
603 FAIL_WITH_STRERROR("stat");
604 }
605
606 // Map it.
607 void* data = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd.get(), 0);
608 if (data == MAP_FAILED) {
609 FAIL_WITH_STRERROR("mmap");
610 }
611
612 // Tell the kernel that accesses are likely to be random rather than sequential.
613 if (madvise(data, sb.st_size, MADV_RANDOM) == -1) {
614 FAIL_WITH_STRERROR("madvise(MADV_RANDOM)");
615 }
616
617 // Tell ICU to use our memory-mapped data.
618 UErrorCode status = U_ZERO_ERROR;
619 udata_setCommonData(data, &status);
620 MAYBE_FAIL_WITH_ICU_ERROR("udata_setCommonData");
621 // Tell ICU it can *only* use our memory-mapped data.
622 udata_setFileAccess(UDATA_NO_FILES, &status);
623 MAYBE_FAIL_WITH_ICU_ERROR("udata_setFileAccess");
624
625 // Failures to find the ICU data tend to be somewhat obscure because ICU loads its data on first
626 // use, which can be anywhere. Force initialization up front so we can report a nice clear error
627 // and bail.
628 u_init(&status);
629 MAYBE_FAIL_WITH_ICU_ERROR("u_init");
630 jniRegisterNativeMethods(env, "libcore/icu/ICU", gMethods, NELEM(gMethods));
631 }
632