full selection
[nikiroo-utils.git] / src / be / nikiroo / fanfix / reader / BasicReader.java
1 package be.nikiroo.fanfix.reader;
2
3 import java.io.File;
4 import java.io.IOException;
5 import java.net.MalformedURLException;
6 import java.net.URL;
7 import java.text.ParseException;
8 import java.text.SimpleDateFormat;
9 import java.util.Date;
10 import java.util.Map;
11 import java.util.TreeMap;
12
13 import be.nikiroo.fanfix.Instance;
14 import be.nikiroo.fanfix.bundles.Config;
15 import be.nikiroo.fanfix.bundles.UiConfig;
16 import be.nikiroo.fanfix.data.MetaData;
17 import be.nikiroo.fanfix.data.Story;
18 import be.nikiroo.fanfix.library.BasicLibrary;
19 import be.nikiroo.fanfix.library.LocalLibrary;
20 import be.nikiroo.fanfix.supported.BasicSupport;
21 import be.nikiroo.utils.Progress;
22 import be.nikiroo.utils.StringUtils;
23 import be.nikiroo.utils.serial.SerialUtils;
24
25 /**
26 * The class that handles the different {@link Story} readers you can use.
27 * <p>
28 * All the readers should be accessed via {@link BasicReader#getReader()}.
29 *
30 * @author niki
31 */
32 public abstract class BasicReader implements Reader {
33 private static BasicLibrary defaultLibrary = Instance.getLibrary();
34 private static ReaderType defaultType = ReaderType.GUI;
35
36 private BasicLibrary lib;
37 private MetaData meta;
38 private Story story;
39 private int chapter;
40
41 /**
42 * Take the default reader type configuration from the config file.
43 */
44 static {
45 String typeString = Instance.getConfig().getString(Config.READER_TYPE);
46 if (typeString != null && !typeString.isEmpty()) {
47 try {
48 ReaderType type = ReaderType.valueOf(typeString.toUpperCase());
49 defaultType = type;
50 } catch (IllegalArgumentException e) {
51 // Do nothing
52 }
53 }
54 }
55
56 @Override
57 public synchronized Story getStory(Progress pg) {
58 if (story == null) {
59 story = getLibrary().getStory(meta.getLuid(), pg);
60 }
61
62 return story;
63 }
64
65 @Override
66 public BasicLibrary getLibrary() {
67 if (lib == null) {
68 lib = defaultLibrary;
69 }
70
71 return lib;
72 }
73
74 @Override
75 public void setLibrary(BasicLibrary lib) {
76 this.lib = lib;
77 }
78
79 @Override
80 public synchronized MetaData getMeta() {
81 return meta;
82 }
83
84 @Override
85 public synchronized void setMeta(MetaData meta) throws IOException {
86 setMeta(meta == null ? null : meta.getLuid()); // must check the library
87 }
88
89 @Override
90 public synchronized void setMeta(String luid) throws IOException {
91 story = null;
92 meta = getLibrary().getInfo(luid);
93
94 if (meta == null) {
95 throw new IOException("Cannot retrieve story from library: " + luid);
96 }
97 }
98
99 @Override
100 public synchronized void setMeta(URL url, Progress pg) throws IOException {
101 BasicSupport support = BasicSupport.getSupport(url);
102 if (support == null) {
103 throw new IOException("URL not supported: " + url.toString());
104 }
105
106 story = support.process(pg);
107 if (story == null) {
108 throw new IOException(
109 "Cannot retrieve story from external source: "
110 + url.toString());
111 }
112
113 meta = story.getMeta();
114 }
115
116 @Override
117 public int getChapter() {
118 return chapter;
119 }
120
121 @Override
122 public void setChapter(int chapter) {
123 this.chapter = chapter;
124 }
125
126 /**
127 * Return a new {@link BasicReader} ready for use if one is configured.
128 * <p>
129 * Can return NULL if none are configured.
130 *
131 * @return a {@link BasicReader}, or NULL if none configured
132 */
133 public static Reader getReader() {
134 try {
135 if (defaultType != null) {
136 return (Reader) SerialUtils.createObject(defaultType
137 .getTypeName());
138 }
139 } catch (Exception e) {
140 Instance.getTraceHandler().error(
141 new Exception("Cannot create a reader of type: "
142 + defaultType + " (Not compiled in?)", e));
143 }
144
145 return null;
146 }
147
148 /**
149 * The default {@link Reader.ReaderType} used when calling
150 * {@link BasicReader#getReader()}.
151 *
152 * @return the default type
153 */
154 public static ReaderType getDefaultReaderType() {
155 return defaultType;
156 }
157
158 /**
159 * The default {@link Reader.ReaderType} used when calling
160 * {@link BasicReader#getReader()}.
161 *
162 * @param defaultType
163 * the new default type
164 */
165 public static void setDefaultReaderType(ReaderType defaultType) {
166 BasicReader.defaultType = defaultType;
167 }
168
169 /**
170 * Change the default {@link LocalLibrary} to open with the
171 * {@link BasicReader}s.
172 *
173 * @param lib
174 * the new {@link LocalLibrary}
175 */
176 public static void setDefaultLibrary(BasicLibrary lib) {
177 BasicReader.defaultLibrary = lib;
178 }
179
180 /**
181 * Return an {@link URL} from this {@link String}, be it a file path or an
182 * actual {@link URL}.
183 *
184 * @param sourceString
185 * the source
186 *
187 * @return the corresponding {@link URL}
188 *
189 * @throws MalformedURLException
190 * if this is neither a file nor a conventional {@link URL}
191 */
192 public static URL getUrl(String sourceString) throws MalformedURLException {
193 if (sourceString == null || sourceString.isEmpty()) {
194 throw new MalformedURLException("Empty url");
195 }
196
197 URL source = null;
198 try {
199 source = new URL(sourceString);
200 } catch (MalformedURLException e) {
201 File sourceFile = new File(sourceString);
202 source = sourceFile.toURI().toURL();
203 }
204
205 return source;
206 }
207
208 /**
209 * Describe a {@link Story} from its {@link MetaData} and return a list of
210 * title/value that represent this {@link Story}.
211 *
212 * @param meta
213 * the {@link MetaData} to represent
214 *
215 * @return the information
216 */
217 public static Map<String, String> getMetaDesc(MetaData meta) {
218 Map<String, String> metaDesc = new TreeMap<String, String>();
219
220 // TODO: i18n
221
222 StringBuilder tags = new StringBuilder();
223 for (String tag : meta.getTags()) {
224 if (tags.length() > 0) {
225 tags.append(", ");
226 }
227 tags.append(tag);
228 }
229
230 metaDesc.put("Author", meta.getAuthor());
231 metaDesc.put("Publication date", formatDate(meta.getDate()));
232 metaDesc.put("Published on", meta.getPublisher());
233 metaDesc.put("URL", meta.getUrl());
234 if (meta.isImageDocument()) {
235 metaDesc.put("Number of images", format(meta.getWords()));
236 } else {
237 metaDesc.put("Number of words", format(meta.getWords()));
238 }
239 metaDesc.put("Source", meta.getSource());
240 metaDesc.put("Subject", meta.getSubject());
241 metaDesc.put("Language", meta.getLang());
242 metaDesc.put("Tags", tags.toString());
243
244 return metaDesc;
245 }
246
247 /**
248 * Open the {@link Story} with an external reader (the program will be
249 * passed the main file associated with this {@link Story}).
250 *
251 * @param lib
252 * the {@link BasicLibrary} to select the {@link Story} from
253 * @param luid
254 * the {@link Story} LUID
255 * @param sync
256 * execute the process synchronously (wait until it is terminated
257 * before returning)
258 *
259 * @throws IOException
260 * in case of I/O error
261 */
262 @Override
263 public void openExternal(BasicLibrary lib, String luid, boolean sync)
264 throws IOException {
265 MetaData meta = lib.getInfo(luid);
266 File target = lib.getFile(luid, null);
267
268 openExternal(meta, target, sync);
269 }
270
271 /**
272 * Open the {@link Story} with an external reader (the program will be
273 * passed the given target file).
274 *
275 * @param meta
276 * the {@link Story} to load
277 * @param target
278 * the target {@link File}
279 * @param sync
280 * execute the process synchronously (wait until it is terminated
281 * before returning)
282 *
283 * @throws IOException
284 * in case of I/O error
285 */
286 protected void openExternal(MetaData meta, File target, boolean sync)
287 throws IOException {
288 String program = null;
289 if (meta.isImageDocument()) {
290 program = Instance.getUiConfig().getString(
291 UiConfig.IMAGES_DOCUMENT_READER);
292 } else {
293 program = Instance.getUiConfig().getString(
294 UiConfig.NON_IMAGES_DOCUMENT_READER);
295 }
296
297 if (program != null && program.trim().isEmpty()) {
298 program = null;
299 }
300
301 start(target, program, sync);
302 }
303
304 /**
305 * Start a file and open it with the given program if given or the first
306 * default system starter we can find.
307 *
308 * @param target
309 * the target to open
310 * @param program
311 * the program to use or NULL for the default system starter
312 * @param sync
313 * execute the process synchronously (wait until it is terminated
314 * before returning)
315 *
316 * @throws IOException
317 * in case of I/O error
318 */
319 protected void start(File target, String program, boolean sync)
320 throws IOException {
321
322 Process proc = null;
323 if (program == null) {
324 boolean ok = false;
325 for (String starter : new String[] { "xdg-open", "open", "see",
326 "start", "run" }) {
327 try {
328 Instance.getTraceHandler().trace(
329 "starting external program");
330 proc = Runtime.getRuntime().exec(
331 new String[] { starter, target.getAbsolutePath() });
332 ok = true;
333 break;
334 } catch (IOException e) {
335 }
336 }
337 if (!ok) {
338 throw new IOException("Cannot find a program to start the file");
339 }
340 } else {
341 Instance.getTraceHandler().trace("starting external program");
342 proc = Runtime.getRuntime().exec(
343 new String[] { program, target.getAbsolutePath() });
344 }
345
346 if (proc != null && sync) {
347 try {
348 proc.waitFor();
349 } catch (InterruptedException e) {
350 }
351 }
352 }
353
354 static private String format(long value) {
355 String display = "";
356 String suffix = "";
357
358 if (value > 4000) {
359 value = value / 1000;
360 suffix = "k";
361 }
362
363 while (value > 0) {
364 if (!display.isEmpty()) {
365 display = "." + display;
366 }
367 display = (value % 1000) + display;
368 value = value / 1000;
369 }
370
371 return display + suffix;
372 }
373
374 static private String formatDate(String date) {
375 long ms = 0;
376
377 try {
378 ms = StringUtils.toTime(date);
379 } catch (ParseException e) {
380 }
381
382 if (ms <= 0) {
383 SimpleDateFormat sdf = new SimpleDateFormat(
384 "yyyy-MM-dd'T'HH:mm:ssSSS");
385 try {
386 ms = sdf.parse(date).getTime();
387 } catch (ParseException e) {
388 }
389 }
390
391 if (ms > 0) {
392 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
393 return sdf.format(new Date(ms));
394 }
395
396 // :(
397 return date;
398 }
399 }