1 package org.apache.turbine.services.mimetype;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 import java.io.File;
20 import java.io.IOException;
21
22 import java.util.Locale;
23
24 import org.apache.commons.configuration.Configuration;
25
26 import org.apache.turbine.services.InitializationException;
27 import org.apache.turbine.services.TurbineBaseService;
28 import org.apache.turbine.services.mimetype.util.CharSetMap;
29 import org.apache.turbine.services.mimetype.util.MimeType;
30 import org.apache.turbine.services.mimetype.util.MimeTypeMap;
31 import org.apache.turbine.services.servlet.TurbineServlet;
32
33 /***
34 * The MimeType Service maintains mappings between MIME types and
35 * the corresponding file name extensions, and between locales and
36 * character encodings.
37 *
38 * <p>The MIME type mappings can be defined in MIME type files
39 * located in user's home directory, Java home directory or
40 * the current class jar. The default mapping file is defined
41 * with the mime.type.file property. In addition, the service maintains
42 * a set of most common mappings.
43 *
44 * <p>The charset mappings can be defined in property files
45 * located in user's home directory, Java home directory or
46 * the current class jar. The default mapping file is defined
47 * with the charset.file property. In addition, the service maintains
48 * a set of most common mappings.
49 *
50 * @author <a href="mailto:ilkka.priha@simsoft.fi">Ilkka Priha</a>
51 * @version $Id: TurbineMimeTypeService.java 264148 2005-08-29 14:21:04Z henning $
52 */
53 public class TurbineMimeTypeService
54 extends TurbineBaseService
55 implements MimeTypeService
56 {
57 /***
58 * The MIME type file property.
59 */
60 public static final String MIME_TYPES = "mime.types";
61
62 /***
63 * The charset file property.
64 */
65 public static final String CHARSETS = "charsets";
66
67 /***
68 * The MIME type map used by the service.
69 */
70 private MimeTypeMap mimeTypeMap;
71
72 /***
73 * The charset map used by the service.
74 */
75 private CharSetMap charSetMap;
76
77 /***
78 * Constructs a new service.
79 */
80 public TurbineMimeTypeService()
81 {
82 }
83
84 /***
85 * Initializes the service.
86 *
87 * @throws InitializationException if initialization fails.
88 */
89 public void init()
90 throws InitializationException
91 {
92 String path = null;
93 Configuration conf = getConfiguration();
94 if (conf != null)
95 {
96 path = conf.getString(MIME_TYPES);
97 if (path != null)
98 {
99 path = TurbineServlet.getRealPath(path);
100 }
101 }
102 if (path != null)
103 {
104 try
105 {
106 mimeTypeMap = new MimeTypeMap(path);
107 }
108 catch (IOException x)
109 {
110 throw new InitializationException(path, x);
111 }
112 }
113 else
114 {
115 mimeTypeMap = new MimeTypeMap();
116 }
117
118 if (conf != null)
119 {
120 path = conf.getString(CHARSETS);
121 if (path != null)
122 {
123 path = TurbineServlet.getRealPath(path);
124 }
125 }
126 if (path != null)
127 {
128 try
129 {
130 charSetMap = new CharSetMap(path);
131 }
132 catch (IOException x)
133 {
134 throw new InitializationException(path, x);
135 }
136 }
137 else
138 {
139 charSetMap = new CharSetMap();
140 }
141 setInit(true);
142 }
143
144 /***
145 * Sets a MIME content type mapping to extensions to the map.
146 * The extension is specified by a MIME type name followed
147 * by a list of file name extensions separated by a whitespace.
148 *
149 * @param spec a MIME type extension specification to add.
150 */
151 public void setContentType(String spec)
152 {
153 mimeTypeMap.setContentType(spec);
154 }
155
156 /***
157 * Gets the MIME content type for a file as a string.
158 *
159 * @param file the file.
160 * @return the MIME type string.
161 */
162 public String getContentType(File file)
163 {
164 return mimeTypeMap.getContentType(file);
165 }
166
167 /***
168 * Gets the MIME content type for a named file as a string.
169 *
170 * @param name the name of the file.
171 * @return the MIME type string.
172 */
173 public String getContentType(String name)
174 {
175 return mimeTypeMap.getContentType(name);
176 }
177
178 /***
179 * Gets the MIME content type for a file name extension as a string.
180 *
181 * @param ext the file name extension.
182 * @param def the default type if none is found.
183 * @return the MIME type string.
184 */
185 public String getContentType(String ext,
186 String def)
187 {
188 return mimeTypeMap.getContentType(ext, def);
189 }
190
191 /***
192 * Gets the MIME content type for a file.
193 *
194 * @param file the file.
195 * @return the MIME type.
196 */
197 public MimeType getMimeContentType(File file)
198 {
199 return mimeTypeMap.getMimeContentType(file);
200 }
201
202 /***
203 * Gets the MIME content type for a named file.
204 *
205 * @param name the name of the file.
206 * @return the MIME type.
207 */
208 public MimeType getMimeContentType(String name)
209 {
210 return mimeTypeMap.getMimeContentType(name);
211 }
212
213 /***
214 * Gets the MIME content type for a file name extension.
215 *
216 * @param ext the file name extension.
217 * @param def the default type if none is found.
218 * @return the MIME type.
219 */
220 public MimeType getMimeContentType(String ext,
221 String def)
222 {
223 return mimeTypeMap.getMimeContentType(ext, def);
224 }
225
226 /***
227 * Gets the default file name extension for a MIME type.
228 * Note that the mappers are called in the reverse order.
229 *
230 * @param type the MIME type as a string.
231 * @return the file name extension or null.
232 */
233 public String getDefaultExtension(String type)
234 {
235 return mimeTypeMap.getDefaultExtension(type);
236 }
237
238 /***
239 * Gets the default file name extension for a MIME type.
240 * Note that the mappers are called in the reverse order.
241 *
242 * @param mime the MIME type.
243 * @return the file name extension or null.
244 */
245 public String getDefaultExtension(MimeType mime)
246 {
247 return mimeTypeMap.getDefaultExtension(mime);
248 }
249
250 /***
251 * Sets a locale-charset mapping.
252 *
253 * @param key the key for the charset.
254 * @param charset the corresponding charset.
255 */
256 public void setCharSet(String key,
257 String charset)
258 {
259 charSetMap.setCharSet(key, charset);
260 }
261
262 /***
263 * Gets the charset for a locale. First a locale specific charset
264 * is searched for, then a country specific one and lastly a language
265 * specific one. If none is found, the default charset is returned.
266 *
267 * @param locale the locale.
268 * @return the charset.
269 */
270 public String getCharSet(Locale locale)
271 {
272 return charSetMap.getCharSet(locale);
273 }
274
275 /***
276 * Gets the charset for a locale with a variant. The search
277 * is performed in the following order:
278 * "lang"_"country"_"variant"="charset",
279 * _"counry"_"variant"="charset",
280 * "lang"__"variant"="charset",
281 * __"variant"="charset",
282 * "lang"_"country"="charset",
283 * _"country"="charset",
284 * "lang"="charset".
285 * If nothing of the above is found, the default charset is returned.
286 *
287 * @param locale the locale.
288 * @param variant a variant field.
289 * @return the charset.
290 */
291 public String getCharSet(Locale locale,
292 String variant)
293 {
294 return charSetMap.getCharSet(locale, variant);
295 }
296
297 /***
298 * Gets the charset for a specified key.
299 *
300 * @param key the key for the charset.
301 * @return the found charset or the default one.
302 */
303 public String getCharSet(String key)
304 {
305 return charSetMap.getCharSet(key);
306 }
307
308 /***
309 * Gets the charset for a specified key.
310 *
311 * @param key the key for the charset.
312 * @param def the default charset if none is found.
313 * @return the found charset or the given default.
314 */
315 public String getCharSet(String key,
316 String def)
317 {
318 return charSetMap.getCharSet(key, def);
319 }
320 }