1 /* 2 * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package sun.util.cldr; 27 28 import static sun.util.locale.provider.LocaleProviderAdapter.Type; 29 30 import java.text.MessageFormat; 31 import java.util.Arrays; 32 import java.util.Locale; 33 import java.util.Objects; 34 import java.util.ResourceBundle; 35 import java.util.Set; 36 import java.util.TimeZone; 37 import java.util.stream.Collectors; 38 import sun.util.calendar.ZoneInfoFile; 39 import sun.util.locale.provider.LocaleProviderAdapter; 40 import sun.util.locale.provider.LocaleResources; 41 import sun.util.locale.provider.TimeZoneNameProviderImpl; 42 import sun.util.locale.provider.TimeZoneNameUtility; 43 44 /** 45 * Concrete implementation of the 46 * {@link java.util.spi.TimeZoneNameProvider TimeZoneNameProvider} class 47 * for the CLDR LocaleProviderAdapter. 48 * 49 * @author Naoto Sato 50 */ 51 public class CLDRTimeZoneNameProviderImpl extends TimeZoneNameProviderImpl { 52 53 private static final String NO_INHERITANCE_MARKER = "\u2205\u2205\u2205"; 54 private static class AVAILABLE_IDS { 55 static final String[] INSTANCE = 56 Arrays.stream(ZoneInfoFile.getZoneIds()) 57 .sorted() 58 .toArray(String[]::new); 59 } 60 61 // display name array indexes 62 private static final int INDEX_TZID = 0; 63 private static final int INDEX_STD_LONG = 1; 64 private static final int INDEX_STD_SHORT = 2; 65 private static final int INDEX_DST_LONG = 3; 66 private static final int INDEX_DST_SHORT = 4; 67 private static final int INDEX_GEN_LONG = 5; 68 private static final int INDEX_GEN_SHORT = 6; 69 70 public CLDRTimeZoneNameProviderImpl(Type type, Set<String> langtags) { 71 super(type, langtags); 72 } 73 74 @Override 75 protected String[] getDisplayNameArray(String id, Locale locale) { 76 String tzid = TimeZoneNameUtility.canonicalTZID(id).orElse(id); 77 String[] namesSuper = super.getDisplayNameArray(tzid, locale); 78 79 if (Objects.nonNull(namesSuper)) { 80 // CLDR's resource bundle has an translated entry for this id. 81 // Fix up names if needed, either missing or no-inheritance 82 namesSuper[INDEX_TZID] = id; 83 84 // Check if standard long name exists. If not, try to retrieve the name 85 // from language only locale resources. E.g., "Europe/London" 86 // for en-GB only contains DST names 87 if (!exists(namesSuper, INDEX_STD_LONG) && !locale.getCountry().isEmpty()) { 88 String[] names = 89 getDisplayNameArray(id, Locale.forLanguageTag(locale.getLanguage())); 90 if (exists(names, INDEX_STD_LONG)) { 91 namesSuper[INDEX_STD_LONG] = names[INDEX_STD_LONG]; 92 } 93 } 94 95 for(int i = INDEX_STD_LONG; i < namesSuper.length; i++) { // index 0 is the 'id' itself 96 switch (namesSuper[i]) { 97 case "": 98 // Fill in empty elements 99 deriveFallbackName(namesSuper, i, locale, 100 namesSuper[INDEX_DST_LONG].isEmpty()); 101 break; 102 case NO_INHERITANCE_MARKER: 103 // CLDR's "no inheritance marker" 104 namesSuper[i] = toGMTFormat(id, i == INDEX_DST_LONG || i == INDEX_DST_SHORT, 105 i % 2 != 0, locale); 106 break; 107 default: 108 break; 109 } 110 } 111 return namesSuper; 112 } else { 113 // Derive the names for this id. Validate the id first. 114 if (Arrays.binarySearch(AVAILABLE_IDS.INSTANCE, id) >= 0) { 115 String[] names = new String[INDEX_GEN_SHORT + 1]; 116 names[INDEX_TZID] = id; 117 deriveFallbackNames(names, locale); 118 return names; 119 } 120 } 121 122 return null; 123 } 124 125 @Override 126 protected String[][] getZoneStrings(Locale locale) { 127 // Use English for the ROOT locale 128 locale = locale.equals(Locale.ROOT) ? Locale.ENGLISH : locale; 129 String[][] ret = super.getZoneStrings(locale); 130 131 // Fill in for the empty names. 132 // English names are prefilled for performance. 133 if (locale.getLanguage() != "en") { 134 for (int zoneIndex = 0; zoneIndex < ret.length; zoneIndex++) { 135 deriveFallbackNames(ret[zoneIndex], locale); 136 } 137 } 138 return ret; 139 } 140 141 // Derive fallback time zone name according to LDML's logic 142 private void deriveFallbackNames(String[] names, Locale locale) { 143 for (int i = INDEX_STD_LONG; i <= INDEX_GEN_SHORT; i++) { 144 deriveFallbackName(names, i, locale, false); 145 } 146 } 147 148 private void deriveFallbackName(String[] names, int index, Locale locale, boolean noDST) { 149 if (exists(names, index)) { 150 return; 151 } 152 153 // Check if COMPAT can substitute the name 154 if (LocaleProviderAdapter.getAdapterPreference().contains(Type.JRE)) { 155 String[] compatNames = (String[])LocaleProviderAdapter.forJRE() 156 .getLocaleResources(locale) 157 .getTimeZoneNames(names[INDEX_TZID]); 158 if (compatNames != null) { 159 for (int i = INDEX_STD_LONG; i <= INDEX_GEN_SHORT; i++) { 160 // Assumes COMPAT has no empty slots 161 if (i == index || !exists(names, i)) { 162 names[i] = compatNames[i]; 163 } 164 } 165 return; 166 } 167 } 168 169 // Type Fallback 170 if (noDST && typeFallback(names, index)) { 171 return; 172 } 173 174 // Region Fallback 175 if (regionFormatFallback(names, index, locale)) { 176 return; 177 } 178 179 // last resort 180 String id = names[INDEX_TZID].toUpperCase(Locale.ROOT); 181 if (!id.startsWith("UT")) { 182 names[index] = toGMTFormat(names[INDEX_TZID], 183 index == INDEX_DST_LONG || index == INDEX_DST_SHORT, 184 index % 2 != 0, 185 locale); 186 // aliases of "GMT" timezone. 187 if ((exists(names, INDEX_STD_LONG)) && (id.startsWith("Etc/") 188 || id.startsWith("GMT") || id.startsWith("Greenwich"))) { 189 switch (id) { 190 case "Etc/GMT": 191 case "Etc/GMT-0": 192 case "Etc/GMT+0": 193 case "Etc/GMT0": 194 case "GMT+0": 195 case "GMT-0": 196 case "GMT0": 197 case "Greenwich": 198 names[INDEX_DST_LONG] = names[INDEX_GEN_LONG] = names[INDEX_STD_LONG]; 199 break; 200 } 201 } 202 } 203 } 204 205 private boolean exists(String[] names, int index) { 206 return Objects.nonNull(names) 207 && Objects.nonNull(names[index]) 208 && !names[index].isEmpty(); 209 } 210 211 private boolean typeFallback(String[] names, int index) { 212 // check generic 213 int genIndex = INDEX_GEN_SHORT - index % 2; 214 if (!exists(names, index) && exists(names, genIndex)) { 215 names[index] = names[genIndex]; 216 } else { 217 // check standard 218 int stdIndex = INDEX_STD_SHORT - index % 2; 219 if (!exists(names, index) && exists(names, stdIndex)) { 220 names[index] = names[stdIndex]; 221 } 222 } 223 224 return exists(names, index); 225 } 226 227 private boolean regionFormatFallback(String[] names, int index, Locale l) { 228 String id = names[INDEX_TZID]; 229 LocaleResources lr = LocaleProviderAdapter.forType(Type.CLDR).getLocaleResources(l); 230 ResourceBundle fd = lr.getJavaTimeFormatData(); 231 232 String rgn = (String) lr.getTimeZoneNames("timezone.excity." + id); 233 if (rgn == null && !id.startsWith("Etc") && !id.startsWith("SystemV")) { 234 int slash = id.lastIndexOf('/'); 235 if (slash > 0) { 236 rgn = id.substring(slash + 1).replaceAll("_", " "); 237 } 238 } 239 240 if (rgn != null) { 241 String fmt = ""; 242 switch (index) { 243 case INDEX_STD_LONG: 244 fmt = fd.getString("timezone.regionFormat.standard"); 245 break; 246 case INDEX_DST_LONG: 247 fmt = fd.getString("timezone.regionFormat.daylight"); 248 break; 249 case INDEX_GEN_LONG: 250 fmt = fd.getString("timezone.regionFormat"); 251 break; 252 } 253 if (!fmt.isEmpty()) { 254 names[index] = MessageFormat.format(fmt, rgn); 255 } 256 } 257 258 return exists(names, index); 259 } 260 261 private String toGMTFormat(String id, boolean daylight, boolean isShort, Locale l) { 262 TimeZone tz = ZoneInfoFile.getZoneInfo(id); 263 int offset = (tz.getRawOffset() + (daylight ? tz.getDSTSavings() : 0)) / 60000; 264 LocaleResources lr = LocaleProviderAdapter.forType(Type.CLDR).getLocaleResources(l); 265 ResourceBundle fd = lr.getJavaTimeFormatData(); 266 267 if (offset == 0) { 268 return fd.getString("timezone.gmtZeroFormat"); 269 } else { 270 String gmtFormat = fd.getString("timezone.gmtFormat"); 271 String hourFormat = fd.getString("timezone.hourFormat"); 272 273 if (offset > 0) { 274 hourFormat = hourFormat.substring(0, hourFormat.indexOf(";")); 275 } else { 276 hourFormat = hourFormat.substring(hourFormat.indexOf(";") + 1); 277 offset = -offset; 278 } 279 hourFormat = hourFormat 280 .replaceFirst("H+", (isShort ? "\\%1\\$d" : "\\%1\\$02d")) 281 .replaceFirst("m+", "\\%2\\$02d"); 282 return MessageFormat.format(gmtFormat, 283 String.format(hourFormat, offset / 60, offset % 60)); 284 } 285 } 286 }